Merge pull request #54 from caesarxuchao/release-2.0

Cherry-pick fixes to release 2.0

1.4/Godeps/Godeps.json

@@ -1,116 +0,0 @@
-{
-	"ImportPath": "k8s.io/client-go/1.4",
-	"GoVersion": "go1.6",
-	"GodepVersion": "v74",
-	"Packages": [
-		"./..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "github.com/blang/semver",
-			"Comment": "v3.0.1",
-			"Rev": "31b736133b98f26d5e078ec9eb591666edfd091f"
-		},
-		{
-			"ImportPath": "github.com/davecgh/go-spew/spew",
-			"Rev": "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d"
-		},
-		{
-			"ImportPath": "github.com/docker/distribution/digest",
-			"Comment": "v2.4.0-rc.1-38-gcd27f17",
-			"Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
-		},
-		{
-			"ImportPath": "github.com/docker/distribution/reference",
-			"Comment": "v2.4.0-rc.1-38-gcd27f17",
-			"Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
-		},
-		{
-			"ImportPath": "github.com/emicklei/go-restful",
-			"Comment": "v1.2-79-g89ef8af",
-			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
-		},
-		{
-			"ImportPath": "github.com/emicklei/go-restful/log",
-			"Comment": "v1.2-79-g89ef8af",
-			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
-		},
-		{
-			"ImportPath": "github.com/emicklei/go-restful/swagger",
-			"Comment": "v1.2-79-g89ef8af",
-			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
-		},
-		{
-			"ImportPath": "github.com/ghodss/yaml",
-			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
-		},
-		{
-			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Comment": "v0.2-33-ge18d7aa",
-			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
-		},
-		{
-			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Comment": "v0.2-33-ge18d7aa",
-			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
-		},
-		{
-			"ImportPath": "github.com/golang/glog",
-			"Rev": "44145f04b68cf362d9c4df2182967c2275eaefed"
-		},
-		{
-			"ImportPath": "github.com/golang/groupcache/lru",
-			"Rev": "02826c3e79038b59d737d3b1c0a1d937f71a4433"
-		},
-		{
-			"ImportPath": "github.com/google/gofuzz",
-			"Rev": "bbcb9da2d746f8bdbd6a936686a0a6067ada0ec5"
-		},
-		{
-			"ImportPath": "github.com/imdario/mergo",
-			"Comment": "0.1.3-8-g6633656",
-			"Rev": "6633656539c1639d9d78127b7d47c622b5d7b6dc"
-		},
-		{
-			"ImportPath": "github.com/juju/ratelimit",
-			"Rev": "77ed1c8a01217656d2080ad51981f6e99adaa177"
-		},
-		{
-			"ImportPath": "github.com/pborman/uuid",
-			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
-		},
-		{
-			"ImportPath": "github.com/spf13/pflag",
-			"Rev": "1560c1005499d61b80f865c04d39ca7505bf7f0b"
-		},
-		{
-			"ImportPath": "github.com/ugorji/go/codec",
-			"Rev": "f1f1a805ed361a0e078bb537e4ea78cd37dcf065"
-		},
-		{
-			"ImportPath": "golang.org/x/net/context",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/http2",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/http2/hpack",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/lex/httplex",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "gopkg.in/inf.v0",
-			"Comment": "v0.9.0",
-			"Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
-		},
-		{
-			"ImportPath": "gopkg.in/yaml.v2",
-			"Rev": "53feefa2559fb8dfa8d81baad31be332c97d6c77"
-		}
-	]
-}

1.4/discovery/restmapper_test.go

@@ -1,176 +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 (
-	"reflect"
-	"testing"
-
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-)
-
-func TestRESTMapper(t *testing.T) {
-	resources := []*APIGroupResources{
-		{
-			Group: unversioned.APIGroup{
-				Versions: []unversioned.GroupVersionForDiscovery{
-					{Version: "v1"},
-					{Version: "v2"},
-				},
-				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1"},
-			},
-			VersionedResources: map[string][]unversioned.APIResource{
-				"v1": {
-					{Name: "pods", Namespaced: true, Kind: "Pod"},
-				},
-				"v2": {
-					{Name: "pods", Namespaced: true, Kind: "Pod"},
-				},
-			},
-		},
-		{
-			Group: unversioned.APIGroup{
-				Name: "extensions",
-				Versions: []unversioned.GroupVersionForDiscovery{
-					{Version: "v1beta"},
-				},
-				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1beta"},
-			},
-			VersionedResources: map[string][]unversioned.APIResource{
-				"v1beta": {
-					{Name: "jobs", Namespaced: true, Kind: "Job"},
-				},
-			},
-		},
-	}
-
-	restMapper := NewRESTMapper(resources, nil)
-
-	kindTCs := []struct {
-		input unversioned.GroupVersionResource
-		want  unversioned.GroupVersionKind
-	}{
-		{
-			input: unversioned.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-			want: unversioned.GroupVersionKind{
-				Version: "v1",
-				Kind:    "Pod",
-			},
-		},
-		{
-			input: unversioned.GroupVersionResource{
-				Version:  "v2",
-				Resource: "pods",
-			},
-			want: unversioned.GroupVersionKind{
-				Version: "v2",
-				Kind:    "Pod",
-			},
-		},
-		{
-			input: unversioned.GroupVersionResource{
-				Resource: "pods",
-			},
-			want: unversioned.GroupVersionKind{
-				Version: "v1",
-				Kind:    "Pod",
-			},
-		},
-		{
-			input: unversioned.GroupVersionResource{
-				Resource: "jobs",
-			},
-			want: unversioned.GroupVersionKind{
-				Group:   "extensions",
-				Version: "v1beta",
-				Kind:    "Job",
-			},
-		},
-	}
-
-	for _, tc := range kindTCs {
-		got, err := restMapper.KindFor(tc.input)
-		if err != nil {
-			t.Errorf("KindFor(%#v) unexpected error: %v", tc.input, err)
-			continue
-		}
-
-		if !reflect.DeepEqual(got, tc.want) {
-			t.Errorf("KindFor(%#v) = %#v, want %#v", tc.input, got, tc.want)
-		}
-	}
-
-	resourceTCs := []struct {
-		input unversioned.GroupVersionResource
-		want  unversioned.GroupVersionResource
-	}{
-		{
-			input: unversioned.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-			want: unversioned.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-		},
-		{
-			input: unversioned.GroupVersionResource{
-				Version:  "v2",
-				Resource: "pods",
-			},
-			want: unversioned.GroupVersionResource{
-				Version:  "v2",
-				Resource: "pods",
-			},
-		},
-		{
-			input: unversioned.GroupVersionResource{
-				Resource: "pods",
-			},
-			want: unversioned.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-		},
-		{
-			input: unversioned.GroupVersionResource{
-				Resource: "jobs",
-			},
-			want: unversioned.GroupVersionResource{
-				Group:    "extensions",
-				Version:  "v1beta",
-				Resource: "jobs",
-			},
-		},
-	}
-
-	for _, tc := range resourceTCs {
-		got, err := restMapper.ResourceFor(tc.input)
-		if err != nil {
-			t.Errorf("ResourceFor(%#v) unexpected error: %v", tc.input, err)
-			continue
-		}
-
-		if !reflect.DeepEqual(got, tc.want) {
-			t.Errorf("ResourceFor(%#v) = %#v, want %#v", tc.input, got, tc.want)
-		}
-	}
-}

1.4/dynamic/client_pool.go

@@ -1,95 +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 dynamic
-
-import (
-	"sync"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/runtime/serializer"
-	"k8s.io/client-go/1.4/rest"
-)
-
-// ClientPool manages a pool of dynamic clients.
-type ClientPool interface {
-	// ClientForGroupVersion returns a client configured for the specified groupVersion.
-	ClientForGroupVersion(groupVersion unversioned.GroupVersion) (*Client, error)
-}
-
-// APIPathResolverFunc knows how to convert a groupVersion to its API path.
-type APIPathResolverFunc func(groupVersion unversioned.GroupVersion) string
-
-// LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
-func LegacyAPIPathResolverFunc(groupVersion unversioned.GroupVersion) string {
-	if len(groupVersion.Group) == 0 {
-		return "/api"
-	}
-	return "/apis"
-}
-
-// clientPoolImpl implements Factory
-type clientPoolImpl struct {
-	lock                sync.RWMutex
-	config              *rest.Config
-	clients             map[unversioned.GroupVersion]*Client
-	apiPathResolverFunc APIPathResolverFunc
-}
-
-// NewClientPool returns a ClientPool from the specified config
-func NewClientPool(config *rest.Config, apiPathResolverFunc APIPathResolverFunc) ClientPool {
-	confCopy := *config
-	return &clientPoolImpl{
-		config:              &confCopy,
-		clients:             map[unversioned.GroupVersion]*Client{},
-		apiPathResolverFunc: apiPathResolverFunc,
-	}
-}
-
-// ClientForGroupVersion returns a client for the specified groupVersion, creates one if none exists
-func (c *clientPoolImpl) ClientForGroupVersion(groupVersion unversioned.GroupVersion) (*Client, error) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	// do we have a client already configured?
-	if existingClient, found := c.clients[groupVersion]; found {
-		return existingClient, nil
-	}
-
-	// avoid changing the original config
-	confCopy := *c.config
-	conf := &confCopy
-
-	// we need to set the api path based on group version, if no group, default to legacy path
-	conf.APIPath = c.apiPathResolverFunc(groupVersion)
-
-	// we need to make a client
-	conf.GroupVersion = &groupVersion
-
-	if conf.NegotiatedSerializer == nil {
-		streamingInfo, _ := api.Codecs.StreamingSerializerForMediaType("application/json;stream=watch", nil)
-		conf.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: dynamicCodec{}}, streamingInfo)
-	}
-
-	dynamicClient, err := NewClient(conf)
-	if err != nil {
-		return nil, err
-	}
-	c.clients[groupVersion] = dynamicClient
-	return dynamicClient, nil
-}

1.4/kubernetes/clientset.go

@@ -1,260 +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 kubernetes
-
-import (
-	"github.com/golang/glog"
-	discovery "k8s.io/client-go/1.4/discovery"
-	v1alpha1apps "k8s.io/client-go/1.4/kubernetes/typed/apps/v1alpha1"
-	v1beta1authentication "k8s.io/client-go/1.4/kubernetes/typed/authentication/v1beta1"
-	v1beta1authorization "k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1"
-	v1autoscaling "k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1"
-	v1batch "k8s.io/client-go/1.4/kubernetes/typed/batch/v1"
-	v1alpha1certificates "k8s.io/client-go/1.4/kubernetes/typed/certificates/v1alpha1"
-	v1core "k8s.io/client-go/1.4/kubernetes/typed/core/v1"
-	v1beta1extensions "k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1"
-	v1alpha1policy "k8s.io/client-go/1.4/kubernetes/typed/policy/v1alpha1"
-	v1alpha1rbac "k8s.io/client-go/1.4/kubernetes/typed/rbac/v1alpha1"
-	v1beta1storage "k8s.io/client-go/1.4/kubernetes/typed/storage/v1beta1"
-	"k8s.io/client-go/1.4/pkg/util/flowcontrol"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type Interface interface {
-	Discovery() discovery.DiscoveryInterface
-	Core() v1core.CoreInterface
-	Apps() v1alpha1apps.AppsInterface
-	Authentication() v1beta1authentication.AuthenticationInterface
-	Authorization() v1beta1authorization.AuthorizationInterface
-	Autoscaling() v1autoscaling.AutoscalingInterface
-	Batch() v1batch.BatchInterface
-	Certificates() v1alpha1certificates.CertificatesInterface
-	Extensions() v1beta1extensions.ExtensionsInterface
-	Policy() v1alpha1policy.PolicyInterface
-	Rbac() v1alpha1rbac.RbacInterface
-	Storage() v1beta1storage.StorageInterface
-}
-
-// Clientset contains the clients for groups. Each group has exactly one
-// version included in a Clientset.
-type Clientset struct {
-	*discovery.DiscoveryClient
-	*v1core.CoreClient
-	*v1alpha1apps.AppsClient
-	*v1beta1authentication.AuthenticationClient
-	*v1beta1authorization.AuthorizationClient
-	*v1autoscaling.AutoscalingClient
-	*v1batch.BatchClient
-	*v1alpha1certificates.CertificatesClient
-	*v1beta1extensions.ExtensionsClient
-	*v1alpha1policy.PolicyClient
-	*v1alpha1rbac.RbacClient
-	*v1beta1storage.StorageClient
-}
-
-// Core retrieves the CoreClient
-func (c *Clientset) Core() v1core.CoreInterface {
-	if c == nil {
-		return nil
-	}
-	return c.CoreClient
-}
-
-// Apps retrieves the AppsClient
-func (c *Clientset) Apps() v1alpha1apps.AppsInterface {
-	if c == nil {
-		return nil
-	}
-	return c.AppsClient
-}
-
-// Authentication retrieves the AuthenticationClient
-func (c *Clientset) Authentication() v1beta1authentication.AuthenticationInterface {
-	if c == nil {
-		return nil
-	}
-	return c.AuthenticationClient
-}
-
-// Authorization retrieves the AuthorizationClient
-func (c *Clientset) Authorization() v1beta1authorization.AuthorizationInterface {
-	if c == nil {
-		return nil
-	}
-	return c.AuthorizationClient
-}
-
-// Autoscaling retrieves the AutoscalingClient
-func (c *Clientset) Autoscaling() v1autoscaling.AutoscalingInterface {
-	if c == nil {
-		return nil
-	}
-	return c.AutoscalingClient
-}
-
-// Batch retrieves the BatchClient
-func (c *Clientset) Batch() v1batch.BatchInterface {
-	if c == nil {
-		return nil
-	}
-	return c.BatchClient
-}
-
-// Certificates retrieves the CertificatesClient
-func (c *Clientset) Certificates() v1alpha1certificates.CertificatesInterface {
-	if c == nil {
-		return nil
-	}
-	return c.CertificatesClient
-}
-
-// Extensions retrieves the ExtensionsClient
-func (c *Clientset) Extensions() v1beta1extensions.ExtensionsInterface {
-	if c == nil {
-		return nil
-	}
-	return c.ExtensionsClient
-}
-
-// Policy retrieves the PolicyClient
-func (c *Clientset) Policy() v1alpha1policy.PolicyInterface {
-	if c == nil {
-		return nil
-	}
-	return c.PolicyClient
-}
-
-// Rbac retrieves the RbacClient
-func (c *Clientset) Rbac() v1alpha1rbac.RbacInterface {
-	if c == nil {
-		return nil
-	}
-	return c.RbacClient
-}
-
-// Storage retrieves the StorageClient
-func (c *Clientset) Storage() v1beta1storage.StorageInterface {
-	if c == nil {
-		return nil
-	}
-	return c.StorageClient
-}
-
-// Discovery retrieves the DiscoveryClient
-func (c *Clientset) Discovery() discovery.DiscoveryInterface {
-	return c.DiscoveryClient
-}
-
-// NewForConfig creates a new Clientset for the given config.
-func NewForConfig(c *rest.Config) (*Clientset, error) {
-	configShallowCopy := *c
-	if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
-		configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
-	}
-	var clientset Clientset
-	var err error
-	clientset.CoreClient, err = v1core.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.AppsClient, err = v1alpha1apps.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.AuthenticationClient, err = v1beta1authentication.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.AuthorizationClient, err = v1beta1authorization.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.AutoscalingClient, err = v1autoscaling.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.BatchClient, err = v1batch.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.CertificatesClient, err = v1alpha1certificates.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.ExtensionsClient, err = v1beta1extensions.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.PolicyClient, err = v1alpha1policy.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.RbacClient, err = v1alpha1rbac.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.StorageClient, err = v1beta1storage.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-
-	clientset.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
-	if err != nil {
-		glog.Errorf("failed to create the DiscoveryClient: %v", err)
-		return nil, err
-	}
-	return &clientset, nil
-}
-
-// NewForConfigOrDie creates a new Clientset for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *Clientset {
-	var clientset Clientset
-	clientset.CoreClient = v1core.NewForConfigOrDie(c)
-	clientset.AppsClient = v1alpha1apps.NewForConfigOrDie(c)
-	clientset.AuthenticationClient = v1beta1authentication.NewForConfigOrDie(c)
-	clientset.AuthorizationClient = v1beta1authorization.NewForConfigOrDie(c)
-	clientset.AutoscalingClient = v1autoscaling.NewForConfigOrDie(c)
-	clientset.BatchClient = v1batch.NewForConfigOrDie(c)
-	clientset.CertificatesClient = v1alpha1certificates.NewForConfigOrDie(c)
-	clientset.ExtensionsClient = v1beta1extensions.NewForConfigOrDie(c)
-	clientset.PolicyClient = v1alpha1policy.NewForConfigOrDie(c)
-	clientset.RbacClient = v1alpha1rbac.NewForConfigOrDie(c)
-	clientset.StorageClient = v1beta1storage.NewForConfigOrDie(c)
-
-	clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
-	return &clientset
-}
-
-// New creates a new Clientset for the given RESTClient.
-func New(c *rest.RESTClient) *Clientset {
-	var clientset Clientset
-	clientset.CoreClient = v1core.New(c)
-	clientset.AppsClient = v1alpha1apps.New(c)
-	clientset.AuthenticationClient = v1beta1authentication.New(c)
-	clientset.AuthorizationClient = v1beta1authorization.New(c)
-	clientset.AutoscalingClient = v1autoscaling.New(c)
-	clientset.BatchClient = v1batch.New(c)
-	clientset.CertificatesClient = v1alpha1certificates.New(c)
-	clientset.ExtensionsClient = v1beta1extensions.New(c)
-	clientset.PolicyClient = v1alpha1policy.New(c)
-	clientset.RbacClient = v1alpha1rbac.New(c)
-	clientset.StorageClient = v1beta1storage.New(c)
-
-	clientset.DiscoveryClient = discovery.NewDiscoveryClient(c)
-	return &clientset
-}

1.4/kubernetes/fake/clientset_generated.go

@@ -1,138 +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 fake
-
-import (
-	"k8s.io/client-go/1.4/discovery"
-	fakediscovery "k8s.io/client-go/1.4/discovery/fake"
-	clientset "k8s.io/client-go/1.4/kubernetes"
-	v1alpha1apps "k8s.io/client-go/1.4/kubernetes/typed/apps/v1alpha1"
-	fakev1alpha1apps "k8s.io/client-go/1.4/kubernetes/typed/apps/v1alpha1/fake"
-	v1beta1authentication "k8s.io/client-go/1.4/kubernetes/typed/authentication/v1beta1"
-	fakev1beta1authentication "k8s.io/client-go/1.4/kubernetes/typed/authentication/v1beta1/fake"
-	v1beta1authorization "k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1"
-	fakev1beta1authorization "k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/fake"
-	v1autoscaling "k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1"
-	fakev1autoscaling "k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1/fake"
-	v1batch "k8s.io/client-go/1.4/kubernetes/typed/batch/v1"
-	fakev1batch "k8s.io/client-go/1.4/kubernetes/typed/batch/v1/fake"
-	v1alpha1certificates "k8s.io/client-go/1.4/kubernetes/typed/certificates/v1alpha1"
-	fakev1alpha1certificates "k8s.io/client-go/1.4/kubernetes/typed/certificates/v1alpha1/fake"
-	v1core "k8s.io/client-go/1.4/kubernetes/typed/core/v1"
-	fakev1core "k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake"
-	v1beta1extensions "k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1"
-	fakev1beta1extensions "k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake"
-	v1alpha1policy "k8s.io/client-go/1.4/kubernetes/typed/policy/v1alpha1"
-	fakev1alpha1policy "k8s.io/client-go/1.4/kubernetes/typed/policy/v1alpha1/fake"
-	v1alpha1rbac "k8s.io/client-go/1.4/kubernetes/typed/rbac/v1alpha1"
-	fakev1alpha1rbac "k8s.io/client-go/1.4/kubernetes/typed/rbac/v1alpha1/fake"
-	v1beta1storage "k8s.io/client-go/1.4/kubernetes/typed/storage/v1beta1"
-	fakev1beta1storage "k8s.io/client-go/1.4/kubernetes/typed/storage/v1beta1/fake"
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/watch"
-	"k8s.io/client-go/1.4/testing"
-)
-
-// NewSimpleClientset returns a clientset that will respond with the provided objects.
-// It's backed by a very simple object tracker that processes creates, updates and deletions as-is,
-// without applying any validations and/or defaults. It shouldn't be considered a replacement
-// for a real clientset and is mostly useful in simple unit tests.
-func NewSimpleClientset(objects ...runtime.Object) *Clientset {
-	o := testing.NewObjectTracker(api.Scheme, api.Codecs.UniversalDecoder())
-	for _, obj := range objects {
-		if err := o.Add(obj); err != nil {
-			panic(err)
-		}
-	}
-
-	fakePtr := testing.Fake{}
-	fakePtr.AddReactor("*", "*", testing.ObjectReaction(o, registered.RESTMapper()))
-
-	fakePtr.AddWatchReactor("*", testing.DefaultWatchReactor(watch.NewFake(), nil))
-
-	return &Clientset{fakePtr}
-}
-
-// Clientset implements clientset.Interface. Meant to be embedded into a
-// struct to get a default implementation. This makes faking out just the method
-// you want to test easier.
-type Clientset struct {
-	testing.Fake
-}
-
-func (c *Clientset) Discovery() discovery.DiscoveryInterface {
-	return &fakediscovery.FakeDiscovery{Fake: &c.Fake}
-}
-
-var _ clientset.Interface = &Clientset{}
-
-// Core retrieves the CoreClient
-func (c *Clientset) Core() v1core.CoreInterface {
-	return &fakev1core.FakeCore{Fake: &c.Fake}
-}
-
-// Apps retrieves the AppsClient
-func (c *Clientset) Apps() v1alpha1apps.AppsInterface {
-	return &fakev1alpha1apps.FakeApps{Fake: &c.Fake}
-}
-
-// Authentication retrieves the AuthenticationClient
-func (c *Clientset) Authentication() v1beta1authentication.AuthenticationInterface {
-	return &fakev1beta1authentication.FakeAuthentication{Fake: &c.Fake}
-}
-
-// Authorization retrieves the AuthorizationClient
-func (c *Clientset) Authorization() v1beta1authorization.AuthorizationInterface {
-	return &fakev1beta1authorization.FakeAuthorization{Fake: &c.Fake}
-}
-
-// Autoscaling retrieves the AutoscalingClient
-func (c *Clientset) Autoscaling() v1autoscaling.AutoscalingInterface {
-	return &fakev1autoscaling.FakeAutoscaling{Fake: &c.Fake}
-}
-
-// Batch retrieves the BatchClient
-func (c *Clientset) Batch() v1batch.BatchInterface {
-	return &fakev1batch.FakeBatch{Fake: &c.Fake}
-}
-
-// Certificates retrieves the CertificatesClient
-func (c *Clientset) Certificates() v1alpha1certificates.CertificatesInterface {
-	return &fakev1alpha1certificates.FakeCertificates{Fake: &c.Fake}
-}
-
-// Extensions retrieves the ExtensionsClient
-func (c *Clientset) Extensions() v1beta1extensions.ExtensionsInterface {
-	return &fakev1beta1extensions.FakeExtensions{Fake: &c.Fake}
-}
-
-// Policy retrieves the PolicyClient
-func (c *Clientset) Policy() v1alpha1policy.PolicyInterface {
-	return &fakev1alpha1policy.FakePolicy{Fake: &c.Fake}
-}
-
-// Rbac retrieves the RbacClient
-func (c *Clientset) Rbac() v1alpha1rbac.RbacInterface {
-	return &fakev1alpha1rbac.FakeRbac{Fake: &c.Fake}
-}
-
-// Storage retrieves the StorageClient
-func (c *Clientset) Storage() v1beta1storage.StorageInterface {
-	return &fakev1beta1storage.FakeStorage{Fake: &c.Fake}
-}

1.4/kubernetes/typed/apps/v1alpha1/apps_client.go

@@ -1,96 +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 v1alpha1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type AppsInterface interface {
-	GetRESTClient() *rest.RESTClient
-	PetSetsGetter
-}
-
-// AppsClient is used to interact with features provided by the Apps group.
-type AppsClient struct {
-	*rest.RESTClient
-}
-
-func (c *AppsClient) PetSets(namespace string) PetSetInterface {
-	return newPetSets(c, namespace)
-}
-
-// NewForConfig creates a new AppsClient for the given config.
-func NewForConfig(c *rest.Config) (*AppsClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &AppsClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new AppsClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *AppsClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new AppsClient for the given RESTClient.
-func New(c *rest.RESTClient) *AppsClient {
-	return &AppsClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if apps group is not registered, return an error
-	g, err := registered.Group("apps")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/apis"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *AppsClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/apps/v1alpha1/fake/fake_petset.go

@@ -1,127 +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 fake
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
-	v1alpha1 "k8s.io/client-go/1.4/pkg/apis/apps/v1alpha1"
-	labels "k8s.io/client-go/1.4/pkg/labels"
-	watch "k8s.io/client-go/1.4/pkg/watch"
-	testing "k8s.io/client-go/1.4/testing"
-)
-
-// FakePetSets implements PetSetInterface
-type FakePetSets struct {
-	Fake *FakeApps
-	ns   string
-}
-
-var petsetsResource = unversioned.GroupVersionResource{Group: "apps", Version: "v1alpha1", Resource: "petsets"}
-
-func (c *FakePetSets) Create(petSet *v1alpha1.PetSet) (result *v1alpha1.PetSet, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewCreateAction(petsetsResource, c.ns, petSet), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}
-
-func (c *FakePetSets) Update(petSet *v1alpha1.PetSet) (result *v1alpha1.PetSet, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateAction(petsetsResource, c.ns, petSet), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}
-
-func (c *FakePetSets) UpdateStatus(petSet *v1alpha1.PetSet) (*v1alpha1.PetSet, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateSubresourceAction(petsetsResource, "status", c.ns, petSet), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}
-
-func (c *FakePetSets) Delete(name string, options *api.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewDeleteAction(petsetsResource, c.ns, name), &v1alpha1.PetSet{})
-
-	return err
-}
-
-func (c *FakePetSets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
-	action := testing.NewDeleteCollectionAction(petsetsResource, c.ns, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1alpha1.PetSetList{})
-	return err
-}
-
-func (c *FakePetSets) Get(name string) (result *v1alpha1.PetSet, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewGetAction(petsetsResource, c.ns, name), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}
-
-func (c *FakePetSets) List(opts api.ListOptions) (result *v1alpha1.PetSetList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewListAction(petsetsResource, c.ns, opts), &v1alpha1.PetSetList{})
-
-	if obj == nil {
-		return nil, err
-	}
-
-	label := opts.LabelSelector
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1alpha1.PetSetList{}
-	for _, item := range obj.(*v1alpha1.PetSetList).Items {
-		if label.Matches(labels.Set(item.Labels)) {
-			list.Items = append(list.Items, item)
-		}
-	}
-	return list, err
-}
-
-// Watch returns a watch.Interface that watches the requested petSets.
-func (c *FakePetSets) Watch(opts api.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewWatchAction(petsetsResource, c.ns, opts))
-
-}
-
-// Patch applies the patch and returns the patched petSet.
-func (c *FakePetSets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1alpha1.PetSet, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(petsetsResource, c.ns, name, data, subresources...), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}

1.4/kubernetes/typed/apps/v1alpha1/petset.go

@@ -1,165 +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 v1alpha1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	v1alpha1 "k8s.io/client-go/1.4/pkg/apis/apps/v1alpha1"
-	watch "k8s.io/client-go/1.4/pkg/watch"
-)
-
-// PetSetsGetter has a method to return a PetSetInterface.
-// A group's client should implement this interface.
-type PetSetsGetter interface {
-	PetSets(namespace string) PetSetInterface
-}
-
-// PetSetInterface has methods to work with PetSet resources.
-type PetSetInterface interface {
-	Create(*v1alpha1.PetSet) (*v1alpha1.PetSet, error)
-	Update(*v1alpha1.PetSet) (*v1alpha1.PetSet, error)
-	UpdateStatus(*v1alpha1.PetSet) (*v1alpha1.PetSet, error)
-	Delete(name string, options *api.DeleteOptions) error
-	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
-	Get(name string) (*v1alpha1.PetSet, error)
-	List(opts api.ListOptions) (*v1alpha1.PetSetList, error)
-	Watch(opts api.ListOptions) (watch.Interface, error)
-	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1alpha1.PetSet, err error)
-	PetSetExpansion
-}
-
-// petSets implements PetSetInterface
-type petSets struct {
-	client *AppsClient
-	ns     string
-}
-
-// newPetSets returns a PetSets
-func newPetSets(c *AppsClient, namespace string) *petSets {
-	return &petSets{
-		client: c,
-		ns:     namespace,
-	}
-}
-
-// Create takes the representation of a petSet and creates it.  Returns the server's representation of the petSet, and an error, if there is any.
-func (c *petSets) Create(petSet *v1alpha1.PetSet) (result *v1alpha1.PetSet, err error) {
-	result = &v1alpha1.PetSet{}
-	err = c.client.Post().
-		Namespace(c.ns).
-		Resource("petsets").
-		Body(petSet).
-		Do().
-		Into(result)
-	return
-}
-
-// Update takes the representation of a petSet and updates it. Returns the server's representation of the petSet, and an error, if there is any.
-func (c *petSets) Update(petSet *v1alpha1.PetSet) (result *v1alpha1.PetSet, err error) {
-	result = &v1alpha1.PetSet{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("petsets").
-		Name(petSet.Name).
-		Body(petSet).
-		Do().
-		Into(result)
-	return
-}
-
-func (c *petSets) UpdateStatus(petSet *v1alpha1.PetSet) (result *v1alpha1.PetSet, err error) {
-	result = &v1alpha1.PetSet{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("petsets").
-		Name(petSet.Name).
-		SubResource("status").
-		Body(petSet).
-		Do().
-		Into(result)
-	return
-}
-
-// Delete takes name of the petSet and deletes it. Returns an error if one occurs.
-func (c *petSets) Delete(name string, options *api.DeleteOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("petsets").
-		Name(name).
-		Body(options).
-		Do().
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *petSets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("petsets").
-		VersionedParams(&listOptions, api.ParameterCodec).
-		Body(options).
-		Do().
-		Error()
-}
-
-// Get takes name of the petSet, and returns the corresponding petSet object, and an error if there is any.
-func (c *petSets) Get(name string) (result *v1alpha1.PetSet, err error) {
-	result = &v1alpha1.PetSet{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("petsets").
-		Name(name).
-		Do().
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of PetSets that match those selectors.
-func (c *petSets) List(opts api.ListOptions) (result *v1alpha1.PetSetList, err error) {
-	result = &v1alpha1.PetSetList{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("petsets").
-		VersionedParams(&opts, api.ParameterCodec).
-		Do().
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested petSets.
-func (c *petSets) Watch(opts api.ListOptions) (watch.Interface, error) {
-	return c.client.Get().
-		Prefix("watch").
-		Namespace(c.ns).
-		Resource("petsets").
-		VersionedParams(&opts, api.ParameterCodec).
-		Watch()
-}
-
-// Patch applies the patch and returns the patched petSet.
-func (c *petSets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1alpha1.PetSet, err error) {
-	result = &v1alpha1.PetSet{}
-	err = c.client.Patch(pt).
-		Namespace(c.ns).
-		Resource("petsets").
-		SubResource(subresources...).
-		Name(name).
-		Body(data).
-		Do().
-		Into(result)
-	return
-}

1.4/kubernetes/typed/authentication/v1beta1/authentication_client.go

@@ -1,96 +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 v1beta1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type AuthenticationInterface interface {
-	GetRESTClient() *rest.RESTClient
-	TokenReviewsGetter
-}
-
-// AuthenticationClient is used to interact with features provided by the Authentication group.
-type AuthenticationClient struct {
-	*rest.RESTClient
-}
-
-func (c *AuthenticationClient) TokenReviews() TokenReviewInterface {
-	return newTokenReviews(c)
-}
-
-// NewForConfig creates a new AuthenticationClient for the given config.
-func NewForConfig(c *rest.Config) (*AuthenticationClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &AuthenticationClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new AuthenticationClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *AuthenticationClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new AuthenticationClient for the given RESTClient.
-func New(c *rest.RESTClient) *AuthenticationClient {
-	return &AuthenticationClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if authentication group is not registered, return an error
-	g, err := registered.Group("authentication.k8s.io")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/apis"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *AuthenticationClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/authorization/v1beta1/authorization_client.go

@@ -1,96 +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 v1beta1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type AuthorizationInterface interface {
-	GetRESTClient() *rest.RESTClient
-	SubjectAccessReviewsGetter
-}
-
-// AuthorizationClient is used to interact with features provided by the Authorization group.
-type AuthorizationClient struct {
-	*rest.RESTClient
-}
-
-func (c *AuthorizationClient) SubjectAccessReviews() SubjectAccessReviewInterface {
-	return newSubjectAccessReviews(c)
-}
-
-// NewForConfig creates a new AuthorizationClient for the given config.
-func NewForConfig(c *rest.Config) (*AuthorizationClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &AuthorizationClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new AuthorizationClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *AuthorizationClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new AuthorizationClient for the given RESTClient.
-func New(c *rest.RESTClient) *AuthorizationClient {
-	return &AuthorizationClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if authorization group is not registered, return an error
-	g, err := registered.Group("authorization.k8s.io")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/apis"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *AuthorizationClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/autoscaling/v1/autoscaling_client.go

@@ -1,96 +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 v1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type AutoscalingInterface interface {
-	GetRESTClient() *rest.RESTClient
-	HorizontalPodAutoscalersGetter
-}
-
-// AutoscalingClient is used to interact with features provided by the Autoscaling group.
-type AutoscalingClient struct {
-	*rest.RESTClient
-}
-
-func (c *AutoscalingClient) HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface {
-	return newHorizontalPodAutoscalers(c, namespace)
-}
-
-// NewForConfig creates a new AutoscalingClient for the given config.
-func NewForConfig(c *rest.Config) (*AutoscalingClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &AutoscalingClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new AutoscalingClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *AutoscalingClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new AutoscalingClient for the given RESTClient.
-func New(c *rest.RESTClient) *AutoscalingClient {
-	return &AutoscalingClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if autoscaling group is not registered, return an error
-	g, err := registered.Group("autoscaling")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/apis"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *AutoscalingClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/batch/v1/fake/doc.go

@@ -1,20 +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.
-*/
-
-// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/certificates/v1alpha1/certificates_client.go

@@ -1,96 +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 v1alpha1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type CertificatesInterface interface {
-	GetRESTClient() *rest.RESTClient
-	CertificateSigningRequestsGetter
-}
-
-// CertificatesClient is used to interact with features provided by the Certificates group.
-type CertificatesClient struct {
-	*rest.RESTClient
-}
-
-func (c *CertificatesClient) CertificateSigningRequests() CertificateSigningRequestInterface {
-	return newCertificateSigningRequests(c)
-}
-
-// NewForConfig creates a new CertificatesClient for the given config.
-func NewForConfig(c *rest.Config) (*CertificatesClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &CertificatesClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new CertificatesClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *CertificatesClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new CertificatesClient for the given RESTClient.
-func New(c *rest.RESTClient) *CertificatesClient {
-	return &CertificatesClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if certificates group is not registered, return an error
-	g, err := registered.Group("certificates.k8s.io")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/apis"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *CertificatesClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/certificates/v1alpha1/fake/doc.go

@@ -1,20 +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.
-*/
-
-// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/core/v1/core_client.go

@@ -1,171 +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 v1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type CoreInterface interface {
-	GetRESTClient() *rest.RESTClient
-	ComponentStatusesGetter
-	ConfigMapsGetter
-	EndpointsGetter
-	EventsGetter
-	LimitRangesGetter
-	NamespacesGetter
-	NodesGetter
-	PersistentVolumesGetter
-	PersistentVolumeClaimsGetter
-	PodsGetter
-	PodTemplatesGetter
-	ReplicationControllersGetter
-	ResourceQuotasGetter
-	SecretsGetter
-	ServicesGetter
-	ServiceAccountsGetter
-}
-
-// CoreClient is used to interact with features provided by the Core group.
-type CoreClient struct {
-	*rest.RESTClient
-}
-
-func (c *CoreClient) ComponentStatuses() ComponentStatusInterface {
-	return newComponentStatuses(c)
-}
-
-func (c *CoreClient) ConfigMaps(namespace string) ConfigMapInterface {
-	return newConfigMaps(c, namespace)
-}
-
-func (c *CoreClient) Endpoints(namespace string) EndpointsInterface {
-	return newEndpoints(c, namespace)
-}
-
-func (c *CoreClient) Events(namespace string) EventInterface {
-	return newEvents(c, namespace)
-}
-
-func (c *CoreClient) LimitRanges(namespace string) LimitRangeInterface {
-	return newLimitRanges(c, namespace)
-}
-
-func (c *CoreClient) Namespaces() NamespaceInterface {
-	return newNamespaces(c)
-}
-
-func (c *CoreClient) Nodes() NodeInterface {
-	return newNodes(c)
-}
-
-func (c *CoreClient) PersistentVolumes() PersistentVolumeInterface {
-	return newPersistentVolumes(c)
-}
-
-func (c *CoreClient) PersistentVolumeClaims(namespace string) PersistentVolumeClaimInterface {
-	return newPersistentVolumeClaims(c, namespace)
-}
-
-func (c *CoreClient) Pods(namespace string) PodInterface {
-	return newPods(c, namespace)
-}
-
-func (c *CoreClient) PodTemplates(namespace string) PodTemplateInterface {
-	return newPodTemplates(c, namespace)
-}
-
-func (c *CoreClient) ReplicationControllers(namespace string) ReplicationControllerInterface {
-	return newReplicationControllers(c, namespace)
-}
-
-func (c *CoreClient) ResourceQuotas(namespace string) ResourceQuotaInterface {
-	return newResourceQuotas(c, namespace)
-}
-
-func (c *CoreClient) Secrets(namespace string) SecretInterface {
-	return newSecrets(c, namespace)
-}
-
-func (c *CoreClient) Services(namespace string) ServiceInterface {
-	return newServices(c, namespace)
-}
-
-func (c *CoreClient) ServiceAccounts(namespace string) ServiceAccountInterface {
-	return newServiceAccounts(c, namespace)
-}
-
-// NewForConfig creates a new CoreClient for the given config.
-func NewForConfig(c *rest.Config) (*CoreClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &CoreClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new CoreClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *CoreClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new CoreClient for the given RESTClient.
-func New(c *rest.RESTClient) *CoreClient {
-	return &CoreClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if core group is not registered, return an error
-	g, err := registered.Group("")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/api"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *CoreClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/core/v1/fake/doc.go

@@ -1,20 +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.
-*/
-
-// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/core/v1/fake/fake_core_client.go

@@ -1,97 +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 fake
-
-import (
-	v1 "k8s.io/client-go/1.4/kubernetes/typed/core/v1"
-	rest "k8s.io/client-go/1.4/rest"
-	testing "k8s.io/client-go/1.4/testing"
-)
-
-type FakeCore struct {
-	*testing.Fake
-}
-
-func (c *FakeCore) ComponentStatuses() v1.ComponentStatusInterface {
-	return &FakeComponentStatuses{c}
-}
-
-func (c *FakeCore) ConfigMaps(namespace string) v1.ConfigMapInterface {
-	return &FakeConfigMaps{c, namespace}
-}
-
-func (c *FakeCore) Endpoints(namespace string) v1.EndpointsInterface {
-	return &FakeEndpoints{c, namespace}
-}
-
-func (c *FakeCore) Events(namespace string) v1.EventInterface {
-	return &FakeEvents{c, namespace}
-}
-
-func (c *FakeCore) LimitRanges(namespace string) v1.LimitRangeInterface {
-	return &FakeLimitRanges{c, namespace}
-}
-
-func (c *FakeCore) Namespaces() v1.NamespaceInterface {
-	return &FakeNamespaces{c}
-}
-
-func (c *FakeCore) Nodes() v1.NodeInterface {
-	return &FakeNodes{c}
-}
-
-func (c *FakeCore) PersistentVolumes() v1.PersistentVolumeInterface {
-	return &FakePersistentVolumes{c}
-}
-
-func (c *FakeCore) PersistentVolumeClaims(namespace string) v1.PersistentVolumeClaimInterface {
-	return &FakePersistentVolumeClaims{c, namespace}
-}
-
-func (c *FakeCore) Pods(namespace string) v1.PodInterface {
-	return &FakePods{c, namespace}
-}
-
-func (c *FakeCore) PodTemplates(namespace string) v1.PodTemplateInterface {
-	return &FakePodTemplates{c, namespace}
-}
-
-func (c *FakeCore) ReplicationControllers(namespace string) v1.ReplicationControllerInterface {
-	return &FakeReplicationControllers{c, namespace}
-}
-
-func (c *FakeCore) ResourceQuotas(namespace string) v1.ResourceQuotaInterface {
-	return &FakeResourceQuotas{c, namespace}
-}
-
-func (c *FakeCore) Secrets(namespace string) v1.SecretInterface {
-	return &FakeSecrets{c, namespace}
-}
-
-func (c *FakeCore) Services(namespace string) v1.ServiceInterface {
-	return &FakeServices{c, namespace}
-}
-
-func (c *FakeCore) ServiceAccounts(namespace string) v1.ServiceAccountInterface {
-	return &FakeServiceAccounts{c, namespace}
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *FakeCore) GetRESTClient() *rest.RESTClient {
-	return nil
-}

1.4/kubernetes/typed/extensions/v1beta1/extensions_client.go

@@ -1,131 +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 v1beta1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type ExtensionsInterface interface {
-	GetRESTClient() *rest.RESTClient
-	DaemonSetsGetter
-	DeploymentsGetter
-	IngressesGetter
-	JobsGetter
-	PodSecurityPoliciesGetter
-	ReplicaSetsGetter
-	ScalesGetter
-	ThirdPartyResourcesGetter
-}
-
-// ExtensionsClient is used to interact with features provided by the Extensions group.
-type ExtensionsClient struct {
-	*rest.RESTClient
-}
-
-func (c *ExtensionsClient) DaemonSets(namespace string) DaemonSetInterface {
-	return newDaemonSets(c, namespace)
-}
-
-func (c *ExtensionsClient) Deployments(namespace string) DeploymentInterface {
-	return newDeployments(c, namespace)
-}
-
-func (c *ExtensionsClient) Ingresses(namespace string) IngressInterface {
-	return newIngresses(c, namespace)
-}
-
-func (c *ExtensionsClient) Jobs(namespace string) JobInterface {
-	return newJobs(c, namespace)
-}
-
-func (c *ExtensionsClient) PodSecurityPolicies() PodSecurityPolicyInterface {
-	return newPodSecurityPolicies(c)
-}
-
-func (c *ExtensionsClient) ReplicaSets(namespace string) ReplicaSetInterface {
-	return newReplicaSets(c, namespace)
-}
-
-func (c *ExtensionsClient) Scales(namespace string) ScaleInterface {
-	return newScales(c, namespace)
-}
-
-func (c *ExtensionsClient) ThirdPartyResources() ThirdPartyResourceInterface {
-	return newThirdPartyResources(c)
-}
-
-// NewForConfig creates a new ExtensionsClient for the given config.
-func NewForConfig(c *rest.Config) (*ExtensionsClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &ExtensionsClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new ExtensionsClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *ExtensionsClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new ExtensionsClient for the given RESTClient.
-func New(c *rest.RESTClient) *ExtensionsClient {
-	return &ExtensionsClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if extensions group is not registered, return an error
-	g, err := registered.Group("extensions")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/apis"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *ExtensionsClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/extensions/v1beta1/fake/doc.go

@@ -1,20 +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.
-*/
-
-// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/extensions/v1beta1/fake/fake_extensions_client.go

@@ -1,65 +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 fake
-
-import (
-	v1beta1 "k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1"
-	rest "k8s.io/client-go/1.4/rest"
-	testing "k8s.io/client-go/1.4/testing"
-)
-
-type FakeExtensions struct {
-	*testing.Fake
-}
-
-func (c *FakeExtensions) DaemonSets(namespace string) v1beta1.DaemonSetInterface {
-	return &FakeDaemonSets{c, namespace}
-}
-
-func (c *FakeExtensions) Deployments(namespace string) v1beta1.DeploymentInterface {
-	return &FakeDeployments{c, namespace}
-}
-
-func (c *FakeExtensions) Ingresses(namespace string) v1beta1.IngressInterface {
-	return &FakeIngresses{c, namespace}
-}
-
-func (c *FakeExtensions) Jobs(namespace string) v1beta1.JobInterface {
-	return &FakeJobs{c, namespace}
-}
-
-func (c *FakeExtensions) PodSecurityPolicies() v1beta1.PodSecurityPolicyInterface {
-	return &FakePodSecurityPolicies{c}
-}
-
-func (c *FakeExtensions) ReplicaSets(namespace string) v1beta1.ReplicaSetInterface {
-	return &FakeReplicaSets{c, namespace}
-}
-
-func (c *FakeExtensions) Scales(namespace string) v1beta1.ScaleInterface {
-	return &FakeScales{c, namespace}
-}
-
-func (c *FakeExtensions) ThirdPartyResources() v1beta1.ThirdPartyResourceInterface {
-	return &FakeThirdPartyResources{c}
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *FakeExtensions) GetRESTClient() *rest.RESTClient {
-	return nil
-}

1.4/kubernetes/typed/policy/v1alpha1/fake/doc.go

@@ -1,20 +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.
-*/
-
-// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/policy/v1alpha1/policy_client.go

@@ -1,96 +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 v1alpha1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type PolicyInterface interface {
-	GetRESTClient() *rest.RESTClient
-	PodDisruptionBudgetsGetter
-}
-
-// PolicyClient is used to interact with features provided by the Policy group.
-type PolicyClient struct {
-	*rest.RESTClient
-}
-
-func (c *PolicyClient) PodDisruptionBudgets(namespace string) PodDisruptionBudgetInterface {
-	return newPodDisruptionBudgets(c, namespace)
-}
-
-// NewForConfig creates a new PolicyClient for the given config.
-func NewForConfig(c *rest.Config) (*PolicyClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &PolicyClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new PolicyClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *PolicyClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new PolicyClient for the given RESTClient.
-func New(c *rest.RESTClient) *PolicyClient {
-	return &PolicyClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if policy group is not registered, return an error
-	g, err := registered.Group("policy")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/apis"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *PolicyClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/rbac/v1alpha1/fake/doc.go

@@ -1,20 +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.
-*/
-
-// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/rbac/v1alpha1/rbac_client.go

@@ -1,111 +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 v1alpha1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type RbacInterface interface {
-	GetRESTClient() *rest.RESTClient
-	ClusterRolesGetter
-	ClusterRoleBindingsGetter
-	RolesGetter
-	RoleBindingsGetter
-}
-
-// RbacClient is used to interact with features provided by the Rbac group.
-type RbacClient struct {
-	*rest.RESTClient
-}
-
-func (c *RbacClient) ClusterRoles() ClusterRoleInterface {
-	return newClusterRoles(c)
-}
-
-func (c *RbacClient) ClusterRoleBindings() ClusterRoleBindingInterface {
-	return newClusterRoleBindings(c)
-}
-
-func (c *RbacClient) Roles(namespace string) RoleInterface {
-	return newRoles(c, namespace)
-}
-
-func (c *RbacClient) RoleBindings(namespace string) RoleBindingInterface {
-	return newRoleBindings(c, namespace)
-}
-
-// NewForConfig creates a new RbacClient for the given config.
-func NewForConfig(c *rest.Config) (*RbacClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &RbacClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new RbacClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *RbacClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new RbacClient for the given RESTClient.
-func New(c *rest.RESTClient) *RbacClient {
-	return &RbacClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if rbac group is not registered, return an error
-	g, err := registered.Group("rbac.authorization.k8s.io")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/apis"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *RbacClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/storage/v1beta1/fake/doc.go

@@ -1,20 +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.
-*/
-
-// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/storage/v1beta1/storage_client.go

@@ -1,96 +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 v1beta1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.4/rest"
-)
-
-type StorageInterface interface {
-	GetRESTClient() *rest.RESTClient
-	StorageClassesGetter
-}
-
-// StorageClient is used to interact with features provided by the Storage group.
-type StorageClient struct {
-	*rest.RESTClient
-}
-
-func (c *StorageClient) StorageClasses() StorageClassInterface {
-	return newStorageClasses(c)
-}
-
-// NewForConfig creates a new StorageClient for the given config.
-func NewForConfig(c *rest.Config) (*StorageClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &StorageClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new StorageClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *StorageClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new StorageClient for the given RESTClient.
-func New(c *rest.RESTClient) *StorageClient {
-	return &StorageClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if storage group is not registered, return an error
-	g, err := registered.Group("storage.k8s.io")
-	if err != nil {
-		return err
-	}
-	config.APIPath = "/apis"
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	// TODO: Unconditionally set the config.Version, until we fix the config.
-	//if config.Version == "" {
-	copyGroupVersion := g.GroupVersion
-	config.GroupVersion = &copyGroupVersion
-	//}
-
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
-
-	return nil
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *StorageClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/pkg/api/endpoints/util.go

@@ -1,238 +0,0 @@
-/*
-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 endpoints
-
-import (
-	"bytes"
-	"crypto/md5"
-	"encoding/hex"
-	"hash"
-	"sort"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/types"
-	hashutil "k8s.io/client-go/1.4/pkg/util/hash"
-)
-
-const (
-	// TODO: to be deleted after v1.3 is released
-	// Its value is the json representation of map[string(IP)][HostRecord]
-	// example: '{"10.245.1.6":{"HostName":"my-webserver"}}'
-	PodHostnamesAnnotation = "endpoints.beta.kubernetes.io/hostnames-map"
-)
-
-// TODO: to be deleted after v1.3 is released
-type HostRecord struct {
-	HostName string
-}
-
-// RepackSubsets takes a slice of EndpointSubset objects, expands it to the full
-// representation, and then repacks that into the canonical layout.  This
-// ensures that code which operates on these objects can rely on the common
-// form for things like comparison.  The result is a newly allocated slice.
-func RepackSubsets(subsets []api.EndpointSubset) []api.EndpointSubset {
-	// First map each unique port definition to the sets of hosts that
-	// offer it.
-	allAddrs := map[addressKey]*api.EndpointAddress{}
-	portToAddrReadyMap := map[api.EndpointPort]addressSet{}
-	for i := range subsets {
-		for _, port := range subsets[i].Ports {
-			for k := range subsets[i].Addresses {
-				mapAddressByPort(&subsets[i].Addresses[k], port, true, allAddrs, portToAddrReadyMap)
-			}
-			for k := range subsets[i].NotReadyAddresses {
-				mapAddressByPort(&subsets[i].NotReadyAddresses[k], port, false, allAddrs, portToAddrReadyMap)
-			}
-		}
-	}
-
-	// Next, map the sets of hosts to the sets of ports they offer.
-	// Go does not allow maps or slices as keys to maps, so we have
-	// to synthesize an artificial key and do a sort of 2-part
-	// associative entity.
-	type keyString string
-	keyToAddrReadyMap := map[keyString]addressSet{}
-	addrReadyMapKeyToPorts := map[keyString][]api.EndpointPort{}
-	for port, addrs := range portToAddrReadyMap {
-		key := keyString(hashAddresses(addrs))
-		keyToAddrReadyMap[key] = addrs
-		addrReadyMapKeyToPorts[key] = append(addrReadyMapKeyToPorts[key], port)
-	}
-
-	// Next, build the N-to-M association the API wants.
-	final := []api.EndpointSubset{}
-	for key, ports := range addrReadyMapKeyToPorts {
-		var readyAddrs, notReadyAddrs []api.EndpointAddress
-		for addr, ready := range keyToAddrReadyMap[key] {
-			if ready {
-				readyAddrs = append(readyAddrs, *addr)
-			} else {
-				notReadyAddrs = append(notReadyAddrs, *addr)
-			}
-		}
-		final = append(final, api.EndpointSubset{Addresses: readyAddrs, NotReadyAddresses: notReadyAddrs, Ports: ports})
-	}
-
-	// Finally, sort it.
-	return SortSubsets(final)
-}
-
-// The sets of hosts must be de-duped, using IP+UID as the key.
-type addressKey struct {
-	ip  string
-	uid types.UID
-}
-
-// mapAddressByPort adds an address into a map by its ports, registering the address with a unique pointer, and preserving
-// any existing ready state.
-func mapAddressByPort(addr *api.EndpointAddress, port api.EndpointPort, ready bool, allAddrs map[addressKey]*api.EndpointAddress, portToAddrReadyMap map[api.EndpointPort]addressSet) *api.EndpointAddress {
-	// use addressKey to distinguish between two endpoints that are identical addresses
-	// but may have come from different hosts, for attribution. For instance, Mesos
-	// assigns pods the node IP, but the pods are distinct.
-	key := addressKey{ip: addr.IP}
-	if addr.TargetRef != nil {
-		key.uid = addr.TargetRef.UID
-	}
-
-	// Accumulate the address. The full EndpointAddress structure is preserved for use when
-	// we rebuild the subsets so that the final TargetRef has all of the necessary data.
-	existingAddress := allAddrs[key]
-	if existingAddress == nil {
-		// Make a copy so we don't write to the
-		// input args of this function.
-		existingAddress = &api.EndpointAddress{}
-		*existingAddress = *addr
-		allAddrs[key] = existingAddress
-	}
-
-	// Remember that this port maps to this address.
-	if _, found := portToAddrReadyMap[port]; !found {
-		portToAddrReadyMap[port] = addressSet{}
-	}
-	// if we have not yet recorded this port for this address, or if the previous
-	// state was ready, write the current ready state. not ready always trumps
-	// ready.
-	if wasReady, found := portToAddrReadyMap[port][existingAddress]; !found || wasReady {
-		portToAddrReadyMap[port][existingAddress] = ready
-	}
-	return existingAddress
-}
-
-type addressSet map[*api.EndpointAddress]bool
-
-type addrReady struct {
-	addr  *api.EndpointAddress
-	ready bool
-}
-
-func hashAddresses(addrs addressSet) string {
-	// Flatten the list of addresses into a string so it can be used as a
-	// map key.  Unfortunately, DeepHashObject is implemented in terms of
-	// spew, and spew does not handle non-primitive map keys well.  So
-	// first we collapse it into a slice, sort the slice, then hash that.
-	slice := make([]addrReady, 0, len(addrs))
-	for k, ready := range addrs {
-		slice = append(slice, addrReady{k, ready})
-	}
-	sort.Sort(addrsReady(slice))
-	hasher := md5.New()
-	hashutil.DeepHashObject(hasher, slice)
-	return hex.EncodeToString(hasher.Sum(nil)[0:])
-}
-
-func lessAddrReady(a, b addrReady) bool {
-	// ready is not significant to hashing since we can't have duplicate addresses
-	return LessEndpointAddress(a.addr, b.addr)
-}
-
-type addrsReady []addrReady
-
-func (sl addrsReady) Len() int      { return len(sl) }
-func (sl addrsReady) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
-func (sl addrsReady) Less(i, j int) bool {
-	return lessAddrReady(sl[i], sl[j])
-}
-
-func LessEndpointAddress(a, b *api.EndpointAddress) bool {
-	ipComparison := bytes.Compare([]byte(a.IP), []byte(b.IP))
-	if ipComparison != 0 {
-		return ipComparison < 0
-	}
-	if b.TargetRef == nil {
-		return false
-	}
-	if a.TargetRef == nil {
-		return true
-	}
-	return a.TargetRef.UID < b.TargetRef.UID
-}
-
-type addrPtrsByIpAndUID []*api.EndpointAddress
-
-func (sl addrPtrsByIpAndUID) Len() int      { return len(sl) }
-func (sl addrPtrsByIpAndUID) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
-func (sl addrPtrsByIpAndUID) Less(i, j int) bool {
-	return LessEndpointAddress(sl[i], sl[j])
-}
-
-// SortSubsets sorts an array of EndpointSubset objects in place.  For ease of
-// use it returns the input slice.
-func SortSubsets(subsets []api.EndpointSubset) []api.EndpointSubset {
-	for i := range subsets {
-		ss := &subsets[i]
-		sort.Sort(addrsByIpAndUID(ss.Addresses))
-		sort.Sort(addrsByIpAndUID(ss.NotReadyAddresses))
-		sort.Sort(portsByHash(ss.Ports))
-	}
-	sort.Sort(subsetsByHash(subsets))
-	return subsets
-}
-
-func hashObject(hasher hash.Hash, obj interface{}) []byte {
-	hashutil.DeepHashObject(hasher, obj)
-	return hasher.Sum(nil)
-}
-
-type subsetsByHash []api.EndpointSubset
-
-func (sl subsetsByHash) Len() int      { return len(sl) }
-func (sl subsetsByHash) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
-func (sl subsetsByHash) Less(i, j int) bool {
-	hasher := md5.New()
-	h1 := hashObject(hasher, sl[i])
-	h2 := hashObject(hasher, sl[j])
-	return bytes.Compare(h1, h2) < 0
-}
-
-type addrsByIpAndUID []api.EndpointAddress
-
-func (sl addrsByIpAndUID) Len() int      { return len(sl) }
-func (sl addrsByIpAndUID) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
-func (sl addrsByIpAndUID) Less(i, j int) bool {
-	return LessEndpointAddress(&sl[i], &sl[j])
-}
-
-type portsByHash []api.EndpointPort
-
-func (sl portsByHash) Len() int      { return len(sl) }
-func (sl portsByHash) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
-func (sl portsByHash) Less(i, j int) bool {
-	hasher := md5.New()
-	h1 := hashObject(hasher, sl[i])
-	h2 := hashObject(hasher, sl[j])
-	return bytes.Compare(h1, h2) < 0
-}

1.4/pkg/api/node_example.json

@@ -1,49 +0,0 @@
-{
-    "kind": "Node",
-    "apiVersion": "v1",
-    "metadata": {
-        "name": "e2e-test-wojtekt-minion-etd6",
-        "selfLink": "/api/v1/nodes/e2e-test-wojtekt-minion-etd6",
-        "uid": "a7e89222-e8e5-11e4-8fde-42010af09327",
-        "resourceVersion": "379",
-        "creationTimestamp": "2015-04-22T11:49:39Z"
-    },
-    "spec": {
-        "externalID": "15488322946290398375"
-    },
-    "status": {
-        "capacity": {
-            "cpu": "1",
-            "memory": "1745152Ki"
-        },
-        "conditions": [
-            {
-                "type": "Ready",
-                "status": "True",
-                "lastHeartbeatTime": "2015-04-22T11:58:17Z",
-                "lastTransitionTime": "2015-04-22T11:49:52Z",
-                "reason": "kubelet is posting ready status"
-            }
-        ],
-        "addresses": [
-            {
-                "type": "ExternalIP",
-                "address": "104.197.49.213"
-            },
-            {
-                "type": "LegacyHostIP",
-                "address": "104.197.20.11"
-            }
-        ],
-        "nodeInfo": {
-            "machineID": "",
-            "systemUUID": "D59FA3FA-7B5B-7287-5E1A-1D79F13CB577",
-            "bootID": "44a832f3-8cfb-4de5-b7d2-d66030b6cd95",
-            "kernelVersion": "3.16.0-0.bpo.4-amd64",
-            "osImage": "Debian GNU/Linux 7 (wheezy)",
-            "containerRuntimeVersion": "docker://1.5.0",
-            "kubeletVersion": "v0.15.0-484-g0c8ee980d705a3-dirty",
-            "kubeProxyVersion": "v0.15.0-484-g0c8ee980d705a3-dirty"
-        }
-    }
-}

1.4/pkg/api/pod/util.go

@@ -1,61 +0,0 @@
-/*
-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 pod
-
-import (
-	"fmt"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/util/intstr"
-)
-
-const (
-	// TODO: to be de!eted after v1.3 is released. PodSpec has a dedicated Hostname field.
-	// The annotation value is a string specifying the hostname to be used for the pod e.g 'my-webserver-1'
-	PodHostnameAnnotation = "pod.beta.kubernetes.io/hostname"
-
-	// TODO: to be de!eted after v1.3 is released. PodSpec has a dedicated Subdomain field.
-	// The annotation value is a string specifying the subdomain e.g. "my-web-service"
-	// If specified, on the pod itself, "<hostname>.my-web-service.<namespace>.svc.<cluster domain>" would resolve to
-	// the pod's IP.
-	// If there is a headless service named "my-web-service" in the same namespace as the pod, then,
-	// <hostname>.my-web-service.<namespace>.svc.<cluster domain>" would be resolved by the cluster DNS Server.
-	PodSubdomainAnnotation = "pod.beta.kubernetes.io/subdomain"
-)
-
-// FindPort locates the container port for the given pod and portName.  If the
-// targetPort is a number, use that.  If the targetPort is a string, look that
-// string up in all named ports in all containers in the target pod.  If no
-// match is found, fail.
-func FindPort(pod *api.Pod, svcPort *api.ServicePort) (int, error) {
-	portName := svcPort.TargetPort
-	switch portName.Type {
-	case intstr.String:
-		name := portName.StrVal
-		for _, container := range pod.Spec.Containers {
-			for _, port := range container.Ports {
-				if port.Name == name && port.Protocol == svcPort.Protocol {
-					return int(port.ContainerPort), nil
-				}
-			}
-		}
-	case intstr.Int:
-		return portName.IntValue(), nil
-	}
-
-	return 0, fmt.Errorf("no suitable port for manifest: %s", pod.UID)
-}

1.4/pkg/api/replication_controller_example.json

@@ -1,83 +0,0 @@
-{
-    "kind": "ReplicationController",
-    "apiVersion": "v1",
-    "metadata": {
-        "name": "elasticsearch-logging-controller",
-        "namespace": "default",
-        "selfLink": "/api/v1/namespaces/default/replicationcontrollers/elasticsearch-logging-controller",
-        "uid": "aa76f162-e8e5-11e4-8fde-42010af09327",
-        "resourceVersion": "98",
-        "creationTimestamp": "2015-04-22T11:49:43Z",
-        "labels": {
-            "kubernetes.io/cluster-service": "true",
-            "name": "elasticsearch-logging"
-        }
-    },
-    "spec": {
-        "replicas": 1,
-        "selector": {
-            "name": "elasticsearch-logging"
-        },
-        "template": {
-            "metadata": {
-                "creationTimestamp": null,
-                "labels": {
-                    "kubernetes.io/cluster-service": "true",
-                    "name": "elasticsearch-logging"
-                }
-            },
-            "spec": {
-                "volumes": [
-                    {
-                        "name": "es-persistent-storage",
-                        "hostPath": null,
-                        "emptyDir": {
-                            "medium": ""
-                        },
-                        "gcePersistentDisk": null,
-                        "awsElasticBlockStore": null,
-                        "gitRepo": null,
-                        "secret": null,
-                        "nfs": null,
-                        "iscsi": null,
-                        "glusterfs": null,
-                        "quobyte": null
-                    }
-                ],
-                "containers": [
-                    {
-                        "name": "elasticsearch-logging",
-                        "image": "gcr.io/google_containers/elasticsearch:1.0",
-                        "ports": [
-                            {
-                                "name": "db",
-                                "containerPort": 9200,
-                                "protocol": "TCP"
-                            },
-                            {
-                                "name": "transport",
-                                "containerPort": 9300,
-                                "protocol": "TCP"
-                            }
-                        ],
-                        "resources": {},
-                        "volumeMounts": [
-                            {
-                                "name": "es-persistent-storage",
-                                "mountPath": "/data"
-                            }
-                        ],
-                        "terminationMessagePath": "/dev/termination-log",
-                        "imagePullPolicy": "IfNotPresent",
-                        "capabilities": {}
-                    }
-                ],
-                "restartPolicy": "Always",
-                "dnsPolicy": "ClusterFirst"
-            }
-        }
-    },
-    "status": {
-        "replicas": 1
-    }
-}

1.4/pkg/api/service/annotations.go

@@ -1,89 +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 service
-
-import (
-	"strconv"
-
-	"github.com/golang/glog"
-	"k8s.io/client-go/1.4/pkg/api"
-)
-
-const (
-	// AnnotationLoadBalancerSourceRangesKey is the key of the annotation on a service to set allowed ingress ranges on their LoadBalancers
-	//
-	// It should be a comma-separated list of CIDRs, e.g. `0.0.0.0/0` to
-	// allow full access (the default) or `18.0.0.0/8,56.0.0.0/8` to allow
-	// access only from the CIDRs currently allocated to MIT & the USPS.
-	//
-	// Not all cloud providers support this annotation, though AWS & GCE do.
-	AnnotationLoadBalancerSourceRangesKey = "service.beta.kubernetes.io/load-balancer-source-ranges"
-
-	// AnnotationExternalTraffic An annotation that denotes if this Service desires to route external traffic to local
-	// endpoints only. This preserves Source IP and avoids a second hop.
-	AnnotationExternalTraffic = "service.alpha.kubernetes.io/external-traffic"
-	// AnnotationValueExternalTrafficLocal Value of annotation to specify local endpoints behaviour
-	AnnotationValueExternalTrafficLocal = "OnlyLocal"
-	// AnnotationValueExternalTrafficGlobal Value of annotation to specify global (legacy) behaviour
-	AnnotationValueExternalTrafficGlobal = "Global"
-	// AnnotationHealthCheckNodePort Annotation specifying the healthcheck nodePort for the service
-	// If not specified, annotation is created by the service api backend with the allocated nodePort
-	// Will use user-specified nodePort value if specified by the client
-	AnnotationHealthCheckNodePort = "service.alpha.kubernetes.io/healthcheck-nodeport"
-)
-
-// NeedsHealthCheck Check service for health check annotations
-func NeedsHealthCheck(service *api.Service) bool {
-	if l, ok := service.Annotations[AnnotationExternalTraffic]; ok {
-		if l == AnnotationValueExternalTrafficLocal {
-			return true
-		} else if l == AnnotationValueExternalTrafficGlobal {
-			return false
-		} else {
-			glog.Errorf("Invalid value for annotation %v", AnnotationExternalTraffic)
-			return false
-		}
-	}
-	return false
-}
-
-// GetServiceHealthCheckNodePort Return health check node port annotation for service, if one exists
-func GetServiceHealthCheckNodePort(service *api.Service) int32 {
-	if NeedsHealthCheck(service) {
-		if l, ok := service.Annotations[AnnotationHealthCheckNodePort]; ok {
-			p, err := strconv.Atoi(l)
-			if err != nil {
-				glog.Errorf("Failed to parse annotation %v: %v", AnnotationHealthCheckNodePort, err)
-				return 0
-			}
-			return int32(p)
-		}
-	}
-	return 0
-}
-
-// GetServiceHealthCheckPathPort Return the path and nodePort programmed into the Cloud LB Health Check
-func GetServiceHealthCheckPathPort(service *api.Service) (string, int32) {
-	if !NeedsHealthCheck(service) {
-		return "", 0
-	}
-	port := GetServiceHealthCheckNodePort(service)
-	if port == 0 {
-		return "", 0
-	}
-	return "/healthz", port
-}

1.4/pkg/api/service/util.go

@@ -1,68 +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 service
-
-import (
-	"fmt"
-	"strings"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	netsets "k8s.io/client-go/1.4/pkg/util/net/sets"
-)
-
-const (
-	defaultLoadBalancerSourceRanges = "0.0.0.0/0"
-)
-
-// IsAllowAll checks whether the netsets.IPNet allows traffic from 0.0.0.0/0
-func IsAllowAll(ipnets netsets.IPNet) bool {
-	for _, s := range ipnets.StringSlice() {
-		if s == "0.0.0.0/0" {
-			return true
-		}
-	}
-	return false
-}
-
-// GetLoadBalancerSourceRanges first try to parse and verify LoadBalancerSourceRanges field from a service.
-// If the field is not specified, turn to parse and verify the AnnotationLoadBalancerSourceRangesKey annotation from a service,
-// extracting the source ranges to allow, and if not present returns a default (allow-all) value.
-func GetLoadBalancerSourceRanges(service *api.Service) (netsets.IPNet, error) {
-	var ipnets netsets.IPNet
-	var err error
-	// if SourceRange field is specified, ignore sourceRange annotation
-	if len(service.Spec.LoadBalancerSourceRanges) > 0 {
-		specs := service.Spec.LoadBalancerSourceRanges
-		ipnets, err = netsets.ParseIPNets(specs...)
-
-		if err != nil {
-			return nil, fmt.Errorf("service.Spec.LoadBalancerSourceRanges: %v is not valid. Expecting a list of IP ranges. For example, 10.0.0.0/24. Error msg: %v", specs, err)
-		}
-	} else {
-		val := service.Annotations[AnnotationLoadBalancerSourceRangesKey]
-		val = strings.TrimSpace(val)
-		if val == "" {
-			val = defaultLoadBalancerSourceRanges
-		}
-		specs := strings.Split(val, ",")
-		ipnets, err = netsets.ParseIPNets(specs...)
-		if err != nil {
-			return nil, fmt.Errorf("%s: %s is not valid. Expecting a comma-separated list of source IP ranges. For example, 10.0.0.0/24,192.168.2.0/24", AnnotationLoadBalancerSourceRangesKey, val)
-		}
-	}
-	return ipnets, nil
-}

1.4/pkg/api/unversioned/validation/validation.go

@@ -1,74 +0,0 @@
-/*
-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 validation
-
-import (
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/util/validation"
-	"k8s.io/client-go/1.4/pkg/util/validation/field"
-)
-
-func ValidateLabelSelector(ps *unversioned.LabelSelector, fldPath *field.Path) field.ErrorList {
-	allErrs := field.ErrorList{}
-	if ps == nil {
-		return allErrs
-	}
-	allErrs = append(allErrs, ValidateLabels(ps.MatchLabels, fldPath.Child("matchLabels"))...)
-	for i, expr := range ps.MatchExpressions {
-		allErrs = append(allErrs, ValidateLabelSelectorRequirement(expr, fldPath.Child("matchExpressions").Index(i))...)
-	}
-	return allErrs
-}
-
-func ValidateLabelSelectorRequirement(sr unversioned.LabelSelectorRequirement, fldPath *field.Path) field.ErrorList {
-	allErrs := field.ErrorList{}
-	switch sr.Operator {
-	case unversioned.LabelSelectorOpIn, unversioned.LabelSelectorOpNotIn:
-		if len(sr.Values) == 0 {
-			allErrs = append(allErrs, field.Required(fldPath.Child("values"), "must be specified when `operator` is 'In' or 'NotIn'"))
-		}
-	case unversioned.LabelSelectorOpExists, unversioned.LabelSelectorOpDoesNotExist:
-		if len(sr.Values) > 0 {
-			allErrs = append(allErrs, field.Forbidden(fldPath.Child("values"), "may not be specified when `operator` is 'Exists' or 'DoesNotExist'"))
-		}
-	default:
-		allErrs = append(allErrs, field.Invalid(fldPath.Child("operator"), sr.Operator, "not a valid selector operator"))
-	}
-	allErrs = append(allErrs, ValidateLabelName(sr.Key, fldPath.Child("key"))...)
-	return allErrs
-}
-
-// ValidateLabelName validates that the label name is correctly defined.
-func ValidateLabelName(labelName string, fldPath *field.Path) field.ErrorList {
-	allErrs := field.ErrorList{}
-	for _, msg := range validation.IsQualifiedName(labelName) {
-		allErrs = append(allErrs, field.Invalid(fldPath, labelName, msg))
-	}
-	return allErrs
-}
-
-// ValidateLabels validates that a set of labels are correctly defined.
-func ValidateLabels(labels map[string]string, fldPath *field.Path) field.ErrorList {
-	allErrs := field.ErrorList{}
-	for k, v := range labels {
-		allErrs = append(allErrs, ValidateLabelName(k, fldPath)...)
-		for _, msg := range validation.IsValidLabelValue(v) {
-			allErrs = append(allErrs, field.Invalid(fldPath, v, msg))
-		}
-	}
-	return allErrs
-}

1.4/pkg/api/unversioned/well_known_labels.go

@@ -1,30 +0,0 @@
-/*
-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 unversioned
-
-const (
-	// If you add a new topology domain here, also consider adding it to the set of default values
-	// for the scheduler's --failure-domain command-line argument.
-	LabelHostname          = "kubernetes.io/hostname"
-	LabelZoneFailureDomain = "failure-domain.beta.kubernetes.io/zone"
-	LabelZoneRegion        = "failure-domain.beta.kubernetes.io/region"
-
-	LabelInstanceType = "beta.kubernetes.io/instance-type"
-
-	LabelOS   = "beta.kubernetes.io/os"
-	LabelArch = "beta.kubernetes.io/arch"
-)

1.4/pkg/api/util/group_version.go

@@ -1,48 +0,0 @@
-/*
-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.
-*/
-
-// TODO: This GetVersion/GetGroup arrangement is temporary and will be replaced
-// with a GroupAndVersion type.
-package util
-
-import "strings"
-
-func GetVersion(groupVersion string) string {
-	s := strings.Split(groupVersion, "/")
-	if len(s) != 2 {
-		// e.g. return "v1" for groupVersion="v1"
-		return s[len(s)-1]
-	}
-	return s[1]
-}
-
-func GetGroup(groupVersion string) string {
-	s := strings.Split(groupVersion, "/")
-	if len(s) == 1 {
-		// e.g. return "" for groupVersion="v1"
-		return ""
-	}
-	return s[0]
-}
-
-// GetGroupVersion returns the "group/version". It returns "version" is if group
-// is empty. It returns "group/" if version is empty.
-func GetGroupVersion(group, version string) string {
-	if len(group) == 0 {
-		return version
-	}
-	return group + "/" + version
-}

1.4/pkg/api/validation/doc.go

@@ -1,19 +0,0 @@
-/*
-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 validation has functions for validating the correctness of api
-// objects and explaining what is wrong with them when they aren't valid.
-package validation

1.4/pkg/api/validation/events.go

@@ -1,80 +0,0 @@
-/*
-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 validation
-
-import (
-	"fmt"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	apiutil "k8s.io/client-go/1.4/pkg/api/util"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/util/validation"
-	"k8s.io/client-go/1.4/pkg/util/validation/field"
-)
-
-// ValidateEvent makes sure that the event makes sense.
-func ValidateEvent(event *api.Event) field.ErrorList {
-	allErrs := field.ErrorList{}
-
-	// Make sure event.Namespace and the involvedObject.Namespace agree
-	if len(event.InvolvedObject.Namespace) == 0 {
-		// event.Namespace must also be empty (or "default", for compatibility with old clients)
-		if event.Namespace != api.NamespaceNone && event.Namespace != api.NamespaceDefault {
-			allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
-		}
-	} else {
-		// event namespace must match
-		if event.Namespace != event.InvolvedObject.Namespace {
-			allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
-		}
-	}
-
-	// For kinds we recognize, make sure involvedObject.Namespace is set for namespaced kinds
-	if namespaced, err := isNamespacedKind(event.InvolvedObject.Kind, event.InvolvedObject.APIVersion); err == nil {
-		if namespaced && len(event.InvolvedObject.Namespace) == 0 {
-			allErrs = append(allErrs, field.Required(field.NewPath("involvedObject", "namespace"), fmt.Sprintf("required for kind %s", event.InvolvedObject.Kind)))
-		}
-		if !namespaced && len(event.InvolvedObject.Namespace) > 0 {
-			allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, fmt.Sprintf("not allowed for kind %s", event.InvolvedObject.Kind)))
-		}
-	}
-
-	for _, msg := range validation.IsDNS1123Subdomain(event.Namespace) {
-		allErrs = append(allErrs, field.Invalid(field.NewPath("namespace"), event.Namespace, msg))
-	}
-	return allErrs
-}
-
-// Check whether the kind in groupVersion is scoped at the root of the api hierarchy
-func isNamespacedKind(kind, groupVersion string) (bool, error) {
-	group := apiutil.GetGroup(groupVersion)
-	g, err := registered.Group(group)
-	if err != nil {
-		return false, err
-	}
-	restMapping, err := g.RESTMapper.RESTMapping(unversioned.GroupKind{Group: group, Kind: kind}, apiutil.GetVersion(groupVersion))
-	if err != nil {
-		return false, err
-	}
-	scopeName := restMapping.Scope.Name()
-	if scopeName == meta.RESTScopeNameNamespace {
-		return true, nil
-	}
-	return false, nil
-}

1.4/pkg/api/validation/schema.go

@@ -1,370 +0,0 @@
-/*
-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 validation
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"regexp"
-	"strings"
-
-	"github.com/emicklei/go-restful/swagger"
-	"github.com/golang/glog"
-	apiutil "k8s.io/client-go/1.4/pkg/api/util"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	utilerrors "k8s.io/client-go/1.4/pkg/util/errors"
-	"k8s.io/client-go/1.4/pkg/util/yaml"
-)
-
-type InvalidTypeError struct {
-	ExpectedKind reflect.Kind
-	ObservedKind reflect.Kind
-	FieldName    string
-}
-
-func (i *InvalidTypeError) Error() string {
-	return fmt.Sprintf("expected type %s, for field %s, got %s", i.ExpectedKind.String(), i.FieldName, i.ObservedKind.String())
-}
-
-func NewInvalidTypeError(expected reflect.Kind, observed reflect.Kind, fieldName string) error {
-	return &InvalidTypeError{expected, observed, fieldName}
-}
-
-// TypeNotFoundError is returned when specified type
-// can not found in schema
-type TypeNotFoundError string
-
-func (tnfe TypeNotFoundError) Error() string {
-	return fmt.Sprintf("couldn't find type: %s", string(tnfe))
-}
-
-// Schema is an interface that knows how to validate an API object serialized to a byte array.
-type Schema interface {
-	ValidateBytes(data []byte) error
-}
-
-type NullSchema struct{}
-
-func (NullSchema) ValidateBytes(data []byte) error { return nil }
-
-type SwaggerSchema struct {
-	api      swagger.ApiDeclaration
-	delegate Schema // For delegating to other api groups
-}
-
-func NewSwaggerSchemaFromBytes(data []byte, factory Schema) (Schema, error) {
-	schema := &SwaggerSchema{}
-	err := json.Unmarshal(data, &schema.api)
-	if err != nil {
-		return nil, err
-	}
-	schema.delegate = factory
-	return schema, nil
-}
-
-// validateList unpacks a list and validate every item in the list.
-// It return nil if every item is ok.
-// Otherwise it return an error list contain errors of every item.
-func (s *SwaggerSchema) validateList(obj map[string]interface{}) []error {
-	items, exists := obj["items"]
-	if !exists {
-		return []error{fmt.Errorf("no items field in %#v", obj)}
-	}
-	return s.validateItems(items)
-}
-
-func (s *SwaggerSchema) validateItems(items interface{}) []error {
-	allErrs := []error{}
-	itemList, ok := items.([]interface{})
-	if !ok {
-		return append(allErrs, fmt.Errorf("items isn't a slice"))
-	}
-	for i, item := range itemList {
-		fields, ok := item.(map[string]interface{})
-		if !ok {
-			allErrs = append(allErrs, fmt.Errorf("items[%d] isn't a map[string]interface{}", i))
-			continue
-		}
-		groupVersion := fields["apiVersion"]
-		if groupVersion == nil {
-			allErrs = append(allErrs, fmt.Errorf("items[%d].apiVersion not set", i))
-			continue
-		}
-		itemVersion, ok := groupVersion.(string)
-		if !ok {
-			allErrs = append(allErrs, fmt.Errorf("items[%d].apiVersion isn't string type", i))
-			continue
-		}
-		if len(itemVersion) == 0 {
-			allErrs = append(allErrs, fmt.Errorf("items[%d].apiVersion is empty", i))
-		}
-		kind := fields["kind"]
-		if kind == nil {
-			allErrs = append(allErrs, fmt.Errorf("items[%d].kind not set", i))
-			continue
-		}
-		itemKind, ok := kind.(string)
-		if !ok {
-			allErrs = append(allErrs, fmt.Errorf("items[%d].kind isn't string type", i))
-			continue
-		}
-		if len(itemKind) == 0 {
-			allErrs = append(allErrs, fmt.Errorf("items[%d].kind is empty", i))
-		}
-		version := apiutil.GetVersion(itemVersion)
-		errs := s.ValidateObject(item, "", version+"."+itemKind)
-		if len(errs) >= 1 {
-			allErrs = append(allErrs, errs...)
-		}
-	}
-
-	return allErrs
-}
-
-func (s *SwaggerSchema) ValidateBytes(data []byte) error {
-	var obj interface{}
-	out, err := yaml.ToJSON(data)
-	if err != nil {
-		return err
-	}
-	data = out
-	if err := json.Unmarshal(data, &obj); err != nil {
-		return err
-	}
-	fields, ok := obj.(map[string]interface{})
-	if !ok {
-		return fmt.Errorf("error in unmarshaling data %s", string(data))
-	}
-	groupVersion := fields["apiVersion"]
-	if groupVersion == nil {
-		return fmt.Errorf("apiVersion not set")
-	}
-	if _, ok := groupVersion.(string); !ok {
-		return fmt.Errorf("apiVersion isn't string type")
-	}
-	kind := fields["kind"]
-	if kind == nil {
-		return fmt.Errorf("kind not set")
-	}
-	if _, ok := kind.(string); !ok {
-		return fmt.Errorf("kind isn't string type")
-	}
-	if strings.HasSuffix(kind.(string), "List") {
-		return utilerrors.NewAggregate(s.validateList(fields))
-	}
-	version := apiutil.GetVersion(groupVersion.(string))
-	allErrs := s.ValidateObject(obj, "", version+"."+kind.(string))
-	if len(allErrs) == 1 {
-		return allErrs[0]
-	}
-	return utilerrors.NewAggregate(allErrs)
-}
-
-func (s *SwaggerSchema) ValidateObject(obj interface{}, fieldName, typeName string) []error {
-	allErrs := []error{}
-	models := s.api.Models
-	model, ok := models.At(typeName)
-
-	// Verify the api version matches.  This is required for nested types with differing api versions because
-	// s.api only has schema for 1 api version (the parent object type's version).
-	// e.g. an extensions/v1beta1 Template embedding a /v1 Service requires the schema for the extensions/v1beta1
-	// api to delegate to the schema for the /v1 api.
-	// Only do this for !ok objects so that cross ApiVersion vendored types take precedence.
-	if !ok && s.delegate != nil {
-		fields, mapOk := obj.(map[string]interface{})
-		if !mapOk {
-			return append(allErrs, fmt.Errorf("field %s: expected object of type map[string]interface{}, but the actual type is %T", fieldName, obj))
-		}
-		if delegated, err := s.delegateIfDifferentApiVersion(runtime.Unstructured{Object: fields}); delegated {
-			if err != nil {
-				allErrs = append(allErrs, err)
-			}
-			return allErrs
-		}
-	}
-
-	if !ok {
-		return append(allErrs, TypeNotFoundError(typeName))
-	}
-	properties := model.Properties
-	if len(properties.List) == 0 {
-		// The object does not have any sub-fields.
-		return nil
-	}
-	fields, ok := obj.(map[string]interface{})
-	if !ok {
-		return append(allErrs, fmt.Errorf("field %s: expected object of type map[string]interface{}, but the actual type is %T", fieldName, obj))
-	}
-	if len(fieldName) > 0 {
-		fieldName = fieldName + "."
-	}
-	// handle required fields
-	for _, requiredKey := range model.Required {
-		if _, ok := fields[requiredKey]; !ok {
-			allErrs = append(allErrs, fmt.Errorf("field %s: is required", requiredKey))
-		}
-	}
-	for key, value := range fields {
-		details, ok := properties.At(key)
-
-		// Special case for runtime.RawExtension and runtime.Objects because they always fail to validate
-		// This is because the actual values will be of some sub-type (e.g. Deployment) not the expected
-		// super-type (RawExtension)
-		if s.isGenericArray(details) {
-			errs := s.validateItems(value)
-			if len(errs) > 0 {
-				allErrs = append(allErrs, errs...)
-			}
-			continue
-		}
-		if !ok {
-			allErrs = append(allErrs, fmt.Errorf("found invalid field %s for %s", key, typeName))
-			continue
-		}
-		if details.Type == nil && details.Ref == nil {
-			allErrs = append(allErrs, fmt.Errorf("could not find the type of %s from object: %v", key, details))
-		}
-		var fieldType string
-		if details.Type != nil {
-			fieldType = *details.Type
-		} else {
-			fieldType = *details.Ref
-		}
-		if value == nil {
-			glog.V(2).Infof("Skipping nil field: %s", key)
-			continue
-		}
-		errs := s.validateField(value, fieldName+key, fieldType, &details)
-		if len(errs) > 0 {
-			allErrs = append(allErrs, errs...)
-		}
-	}
-	return allErrs
-}
-
-// delegateIfDifferentApiVersion delegates the validation of an object if its ApiGroup does not match the
-// current SwaggerSchema.
-// First return value is true if the validation was delegated (by a different ApiGroup SwaggerSchema)
-// Second return value is the result of the delegated validation if performed.
-func (s *SwaggerSchema) delegateIfDifferentApiVersion(obj runtime.Unstructured) (bool, error) {
-	// Never delegate objects in the same ApiVersion or we will get infinite recursion
-	if !s.isDifferentApiVersion(obj) {
-		return false, nil
-	}
-
-	// Convert the object back into bytes so that we can pass it to the ValidateBytes function
-	m, err := json.Marshal(obj.Object)
-	if err != nil {
-		return true, err
-	}
-
-	// Delegate validation of this object to the correct SwaggerSchema for its ApiGroup
-	return true, s.delegate.ValidateBytes(m)
-}
-
-// isDifferentApiVersion Returns true if obj lives in a different ApiVersion than the SwaggerSchema does.
-// The SwaggerSchema will not be able to process objects in different ApiVersions unless they are vendored.
-func (s *SwaggerSchema) isDifferentApiVersion(obj runtime.Unstructured) bool {
-	groupVersion := obj.GetAPIVersion()
-	return len(groupVersion) > 0 && s.api.ApiVersion != groupVersion
-}
-
-// isGenericArray Returns true if p is an array of generic Objects - either RawExtension or Object.
-func (s *SwaggerSchema) isGenericArray(p swagger.ModelProperty) bool {
-	return p.DataTypeFields.Type != nil &&
-		*p.DataTypeFields.Type == "array" &&
-		p.Items != nil &&
-		p.Items.Ref != nil &&
-		(*p.Items.Ref == "runtime.RawExtension" || *p.Items.Ref == "runtime.Object")
-}
-
-// This matches type name in the swagger spec, such as "v1.Binding".
-var versionRegexp = regexp.MustCompile(`^(v.+|unversioned)\..*`)
-
-func (s *SwaggerSchema) validateField(value interface{}, fieldName, fieldType string, fieldDetails *swagger.ModelProperty) []error {
-	allErrs := []error{}
-	if reflect.TypeOf(value) == nil {
-		return append(allErrs, fmt.Errorf("unexpected nil value for field %v", fieldName))
-	}
-	// TODO: caesarxuchao: because we have multiple group/versions and objects
-	// may reference objects in other group, the commented out way of checking
-	// if a filedType is a type defined by us is outdated. We use a hacky way
-	// for now.
-	// TODO: the type name in the swagger spec is something like "v1.Binding",
-	// and the "v1" is generated from the package name, not the groupVersion of
-	// the type. We need to fix go-restful to embed the group name in the type
-	// name, otherwise we couldn't handle identically named types in different
-	// groups correctly.
-	if versionRegexp.MatchString(fieldType) {
-		// if strings.HasPrefix(fieldType, apiVersion) {
-		return s.ValidateObject(value, fieldName, fieldType)
-	}
-	switch fieldType {
-	case "string":
-		// Be loose about what we accept for 'string' since we use IntOrString in a couple of places
-		_, isString := value.(string)
-		_, isNumber := value.(float64)
-		_, isInteger := value.(int)
-		if !isString && !isNumber && !isInteger {
-			return append(allErrs, NewInvalidTypeError(reflect.String, reflect.TypeOf(value).Kind(), fieldName))
-		}
-	case "array":
-		arr, ok := value.([]interface{})
-		if !ok {
-			return append(allErrs, NewInvalidTypeError(reflect.Array, reflect.TypeOf(value).Kind(), fieldName))
-		}
-		var arrType string
-		if fieldDetails.Items.Ref == nil && fieldDetails.Items.Type == nil {
-			return append(allErrs, NewInvalidTypeError(reflect.Array, reflect.TypeOf(value).Kind(), fieldName))
-		}
-		if fieldDetails.Items.Ref != nil {
-			arrType = *fieldDetails.Items.Ref
-		} else {
-			arrType = *fieldDetails.Items.Type
-		}
-		for ix := range arr {
-			errs := s.validateField(arr[ix], fmt.Sprintf("%s[%d]", fieldName, ix), arrType, nil)
-			if len(errs) > 0 {
-				allErrs = append(allErrs, errs...)
-			}
-		}
-	case "uint64":
-	case "int64":
-	case "integer":
-		_, isNumber := value.(float64)
-		_, isInteger := value.(int)
-		if !isNumber && !isInteger {
-			return append(allErrs, NewInvalidTypeError(reflect.Int, reflect.TypeOf(value).Kind(), fieldName))
-		}
-	case "float64":
-		if _, ok := value.(float64); !ok {
-			return append(allErrs, NewInvalidTypeError(reflect.Float64, reflect.TypeOf(value).Kind(), fieldName))
-		}
-	case "boolean":
-		if _, ok := value.(bool); !ok {
-			return append(allErrs, NewInvalidTypeError(reflect.Bool, reflect.TypeOf(value).Kind(), fieldName))
-		}
-	// API servers before release 1.3 produce swagger spec with `type: "any"` as the fallback type, while newer servers produce spec with `type: "object"`.
-	// We have both here so that kubectl can work with both old and new api servers.
-	case "object":
-	case "any":
-	default:
-		return append(allErrs, fmt.Errorf("unexpected type: %v", fieldType))
-	}
-	return allErrs
-}

1.4/pkg/apimachinery/types.go

@@ -1,52 +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 apimachinery
-
-import (
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/runtime"
-)
-
-// GroupMeta stores the metadata of a group.
-type GroupMeta struct {
-	// GroupVersion represents the preferred version of the group.
-	GroupVersion unversioned.GroupVersion
-
-	// GroupVersions is Group + all versions in that group.
-	GroupVersions []unversioned.GroupVersion
-
-	// Codec is the default codec for serializing output that should use
-	// the preferred version.  Use this Codec when writing to
-	// disk, a data store that is not dynamically versioned, or in tests.
-	// This codec can decode any object that the schema is aware of.
-	Codec runtime.Codec
-
-	// SelfLinker can set or get the SelfLink field of all API types.
-	// TODO: when versioning changes, make this part of each API definition.
-	// TODO(lavalamp): Combine SelfLinker & ResourceVersioner interfaces, force all uses
-	// to go through the InterfacesFor method below.
-	SelfLinker runtime.SelfLinker
-
-	// RESTMapper provides the default mapping between REST paths and the objects declared in api.Scheme and all known
-	// versions.
-	RESTMapper meta.RESTMapper
-
-	// InterfacesFor returns the default Codec and ResourceVersioner for a given version
-	// or an error if the version is not known.
-	InterfacesFor func(version unversioned.GroupVersion) (*meta.VersionInterfaces, error)
-}

1.4/pkg/apis/apps/install/install.go

@@ -1,131 +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 install installs the apps API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/apps"
-	"k8s.io/client-go/1.4/pkg/apis/apps/v1alpha1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/apps"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", apps.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	// the list of kinds that are scoped at the root of the api hierarchy
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
-	rootScoped := sets.NewString()
-
-	ignoredKinds := sets.NewString()
-
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-// interfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1alpha1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(apps.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := apps.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1alpha1.SchemeGroupVersion:
-			if err := v1alpha1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.4/pkg/apis/apps/v1alpha1/types_swagger_doc_generated.go

@@ -1,71 +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 v1alpha1
-
-// This file contains a collection of methods that can be used from go-restful to
-// generate Swagger API documentation for its models. Please read this PR for more
-// information on the implementation: https://github.com/emicklei/go-restful/pull/215
-//
-// TODOs are ignored from the parser (e.g. TODO(andronat):... || TODO:...) if and only if
-// they are on one line! For multiple line or blocks that you want to ignore use ---.
-// Any context after a --- is ignored.
-//
-// Those methods can be generated by using hack/update-generated-swagger-docs.sh
-
-// AUTO-GENERATED FUNCTIONS START HERE
-var map_PetSet = map[string]string{
-	"":       "PetSet represents a set of pods with consistent identities. Identities are defined as:\n - Network: A single stable DNS and hostname.\n - Storage: As many VolumeClaims as requested.\nThe PetSet guarantees that a given network identity will always map to the same storage identity. PetSet is currently in alpha and subject to change without notice.",
-	"spec":   "Spec defines the desired identities of pets in this set.",
-	"status": "Status is the current status of Pets in this PetSet. This data may be out of date by some window of time.",
-}
-
-func (PetSet) SwaggerDoc() map[string]string {
-	return map_PetSet
-}
-
-var map_PetSetList = map[string]string{
-	"": "PetSetList is a collection of PetSets.",
-}
-
-func (PetSetList) SwaggerDoc() map[string]string {
-	return map_PetSetList
-}
-
-var map_PetSetSpec = map[string]string{
-	"":                     "A PetSetSpec is the specification of a PetSet.",
-	"replicas":             "Replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.",
-	"selector":             "Selector is a label query over pods that should match the replica count. If empty, defaulted to labels on the pod template. More info: http://releases.k8s.io/release-1.4/docs/user-guide/labels.md#label-selectors",
-	"template":             "Template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the PetSet will fulfill this Template, but have a unique identity from the rest of the PetSet.",
-	"volumeClaimTemplates": "VolumeClaimTemplates is a list of claims that pets are allowed to reference. The PetSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pet. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.",
-	"serviceName":          "ServiceName is the name of the service that governs this PetSet. This service must exist before the PetSet, and is responsible for the network identity of the set. Pets get DNS/hostnames that follow the pattern: pet-specific-string.serviceName.default.svc.cluster.local where \"pet-specific-string\" is managed by the PetSet controller.",
-}
-
-func (PetSetSpec) SwaggerDoc() map[string]string {
-	return map_PetSetSpec
-}
-
-var map_PetSetStatus = map[string]string{
-	"":                   "PetSetStatus represents the current state of a PetSet.",
-	"observedGeneration": "most recent generation observed by this autoscaler.",
-	"replicas":           "Replicas is the number of actual replicas.",
-}
-
-func (PetSetStatus) SwaggerDoc() map[string]string {
-	return map_PetSetStatus
-}
-
-// AUTO-GENERATED FUNCTIONS END HERE

1.4/pkg/apis/apps/v1alpha1/zz_generated.conversion.go

@@ -1,160 +0,0 @@
-// +build !ignore_autogenerated
-
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// This file was autogenerated by conversion-gen. Do not edit it manually!
-
-package v1alpha1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	apps "k8s.io/client-go/1.4/pkg/apis/apps"
-	conversion "k8s.io/client-go/1.4/pkg/conversion"
-	runtime "k8s.io/client-go/1.4/pkg/runtime"
-)
-
-func init() {
-	SchemeBuilder.Register(RegisterConversions)
-}
-
-// RegisterConversions adds conversion functions to the given scheme.
-// Public to allow building arbitrary schemes.
-func RegisterConversions(scheme *runtime.Scheme) error {
-	return scheme.AddGeneratedConversionFuncs(
-		Convert_v1alpha1_PetSet_To_apps_PetSet,
-		Convert_apps_PetSet_To_v1alpha1_PetSet,
-		Convert_v1alpha1_PetSetList_To_apps_PetSetList,
-		Convert_apps_PetSetList_To_v1alpha1_PetSetList,
-		Convert_v1alpha1_PetSetSpec_To_apps_PetSetSpec,
-		Convert_apps_PetSetSpec_To_v1alpha1_PetSetSpec,
-		Convert_v1alpha1_PetSetStatus_To_apps_PetSetStatus,
-		Convert_apps_PetSetStatus_To_v1alpha1_PetSetStatus,
-	)
-}
-
-func autoConvert_v1alpha1_PetSet_To_apps_PetSet(in *PetSet, out *apps.PetSet, s conversion.Scope) error {
-	SetDefaults_PetSet(in)
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_v1alpha1_PetSetSpec_To_apps_PetSetSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_v1alpha1_PetSetStatus_To_apps_PetSetStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_v1alpha1_PetSet_To_apps_PetSet(in *PetSet, out *apps.PetSet, s conversion.Scope) error {
-	return autoConvert_v1alpha1_PetSet_To_apps_PetSet(in, out, s)
-}
-
-func autoConvert_apps_PetSet_To_v1alpha1_PetSet(in *apps.PetSet, out *PetSet, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_apps_PetSetSpec_To_v1alpha1_PetSetSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_apps_PetSetStatus_To_v1alpha1_PetSetStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_apps_PetSet_To_v1alpha1_PetSet(in *apps.PetSet, out *PetSet, s conversion.Scope) error {
-	return autoConvert_apps_PetSet_To_v1alpha1_PetSet(in, out, s)
-}
-
-func autoConvert_v1alpha1_PetSetList_To_apps_PetSetList(in *PetSetList, out *apps.PetSetList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]apps.PetSet, len(*in))
-		for i := range *in {
-			if err := Convert_v1alpha1_PetSet_To_apps_PetSet(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_v1alpha1_PetSetList_To_apps_PetSetList(in *PetSetList, out *apps.PetSetList, s conversion.Scope) error {
-	return autoConvert_v1alpha1_PetSetList_To_apps_PetSetList(in, out, s)
-}
-
-func autoConvert_apps_PetSetList_To_v1alpha1_PetSetList(in *apps.PetSetList, out *PetSetList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]PetSet, len(*in))
-		for i := range *in {
-			if err := Convert_apps_PetSet_To_v1alpha1_PetSet(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_apps_PetSetList_To_v1alpha1_PetSetList(in *apps.PetSetList, out *PetSetList, s conversion.Scope) error {
-	return autoConvert_apps_PetSetList_To_v1alpha1_PetSetList(in, out, s)
-}
-
-func autoConvert_v1alpha1_PetSetStatus_To_apps_PetSetStatus(in *PetSetStatus, out *apps.PetSetStatus, s conversion.Scope) error {
-	out.ObservedGeneration = in.ObservedGeneration
-	out.Replicas = int(in.Replicas)
-	return nil
-}
-
-func Convert_v1alpha1_PetSetStatus_To_apps_PetSetStatus(in *PetSetStatus, out *apps.PetSetStatus, s conversion.Scope) error {
-	return autoConvert_v1alpha1_PetSetStatus_To_apps_PetSetStatus(in, out, s)
-}
-
-func autoConvert_apps_PetSetStatus_To_v1alpha1_PetSetStatus(in *apps.PetSetStatus, out *PetSetStatus, s conversion.Scope) error {
-	out.ObservedGeneration = in.ObservedGeneration
-	out.Replicas = int32(in.Replicas)
-	return nil
-}
-
-func Convert_apps_PetSetStatus_To_v1alpha1_PetSetStatus(in *apps.PetSetStatus, out *PetSetStatus, s conversion.Scope) error {
-	return autoConvert_apps_PetSetStatus_To_v1alpha1_PetSetStatus(in, out, s)
-}

1.4/pkg/apis/authentication/install/install.go

@@ -1,129 +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 install installs the experimental API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/authentication"
-	"k8s.io/client-go/1.4/pkg/apis/authentication/v1beta1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/authentication"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", authentication.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := authentication.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1beta1.SchemeGroupVersion:
-			if err := v1beta1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	rootScoped := sets.NewString("TokenReview")
-	ignoredKinds := sets.NewString()
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1beta1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(authentication.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}

1.4/pkg/apis/authorization/install/install.go

@@ -1,134 +0,0 @@
-/*
-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 install installs the experimental API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/authorization"
-	"k8s.io/client-go/1.4/pkg/apis/authorization/v1beta1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/authorization"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", authorization.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := authorization.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1beta1.SchemeGroupVersion:
-			if err := v1beta1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	worstToBestGroupVersions := []unversioned.GroupVersion{}
-	for i := len(externalVersions) - 1; i >= 0; i-- {
-		worstToBestGroupVersions = append(worstToBestGroupVersions, externalVersions[i])
-	}
-
-	rootScoped := sets.NewString("SubjectAccessReview", "SelfSubjectAccessReview")
-	ignoredKinds := sets.NewString()
-	return api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1beta1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(authorization.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}

1.4/pkg/apis/autoscaling/install/install.go

@@ -1,135 +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 install installs the experimental API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/autoscaling"
-	"k8s.io/client-go/1.4/pkg/apis/autoscaling/v1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/autoscaling"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", autoscaling.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	// the list of kinds that are scoped at the root of the api hierarchy
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
-	rootScoped := sets.NewString()
-
-	ignoredKinds := sets.NewString()
-
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-// interfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(autoscaling.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := autoscaling.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1.SchemeGroupVersion:
-			if err := v1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.4/pkg/apis/batch/install/install.go

@@ -1,146 +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 install installs the batch API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/batch"
-	"k8s.io/client-go/1.4/pkg/apis/batch/v1"
-	"k8s.io/client-go/1.4/pkg/apis/batch/v2alpha1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/batch"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion, v2alpha1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", batch.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	// the list of kinds that are scoped at the root of the api hierarchy
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
-	rootScoped := sets.NewString()
-
-	ignoredKinds := sets.NewString()
-
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-// interfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	case v2alpha1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(batch.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := batch.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1.SchemeGroupVersion:
-			if err := v1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		case v2alpha1.SchemeGroupVersion:
-			if err := v2alpha1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.4/pkg/apis/batch/v1/zz_generated.conversion.go

@@ -1,334 +0,0 @@
-// +build !ignore_autogenerated
-
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// This file was autogenerated by conversion-gen. Do not edit it manually!
-
-package v1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
-	api_v1 "k8s.io/client-go/1.4/pkg/api/v1"
-	batch "k8s.io/client-go/1.4/pkg/apis/batch"
-	conversion "k8s.io/client-go/1.4/pkg/conversion"
-	runtime "k8s.io/client-go/1.4/pkg/runtime"
-)
-
-func init() {
-	SchemeBuilder.Register(RegisterConversions)
-}
-
-// RegisterConversions adds conversion functions to the given scheme.
-// Public to allow building arbitrary schemes.
-func RegisterConversions(scheme *runtime.Scheme) error {
-	return scheme.AddGeneratedConversionFuncs(
-		Convert_v1_Job_To_batch_Job,
-		Convert_batch_Job_To_v1_Job,
-		Convert_v1_JobCondition_To_batch_JobCondition,
-		Convert_batch_JobCondition_To_v1_JobCondition,
-		Convert_v1_JobList_To_batch_JobList,
-		Convert_batch_JobList_To_v1_JobList,
-		Convert_v1_JobSpec_To_batch_JobSpec,
-		Convert_batch_JobSpec_To_v1_JobSpec,
-		Convert_v1_JobStatus_To_batch_JobStatus,
-		Convert_batch_JobStatus_To_v1_JobStatus,
-		Convert_v1_LabelSelector_To_unversioned_LabelSelector,
-		Convert_unversioned_LabelSelector_To_v1_LabelSelector,
-		Convert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement,
-		Convert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement,
-	)
-}
-
-func autoConvert_v1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
-	SetDefaults_Job(in)
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_v1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_v1_JobStatus_To_batch_JobStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_v1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
-	return autoConvert_v1_Job_To_batch_Job(in, out, s)
-}
-
-func autoConvert_batch_Job_To_v1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_batch_JobSpec_To_v1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_batch_JobStatus_To_v1_JobStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_batch_Job_To_v1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
-	return autoConvert_batch_Job_To_v1_Job(in, out, s)
-}
-
-func autoConvert_v1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
-	out.Type = batch.JobConditionType(in.Type)
-	out.Status = api.ConditionStatus(in.Status)
-	if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
-		return err
-	}
-	out.Reason = in.Reason
-	out.Message = in.Message
-	return nil
-}
-
-func Convert_v1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
-	return autoConvert_v1_JobCondition_To_batch_JobCondition(in, out, s)
-}
-
-func autoConvert_batch_JobCondition_To_v1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
-	out.Type = JobConditionType(in.Type)
-	out.Status = api_v1.ConditionStatus(in.Status)
-	if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
-		return err
-	}
-	out.Reason = in.Reason
-	out.Message = in.Message
-	return nil
-}
-
-func Convert_batch_JobCondition_To_v1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
-	return autoConvert_batch_JobCondition_To_v1_JobCondition(in, out, s)
-}
-
-func autoConvert_v1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]batch.Job, len(*in))
-		for i := range *in {
-			if err := Convert_v1_Job_To_batch_Job(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_v1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
-	return autoConvert_v1_JobList_To_batch_JobList(in, out, s)
-}
-
-func autoConvert_batch_JobList_To_v1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]Job, len(*in))
-		for i := range *in {
-			if err := Convert_batch_Job_To_v1_Job(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_batch_JobList_To_v1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
-	return autoConvert_batch_JobList_To_v1_JobList(in, out, s)
-}
-
-func autoConvert_v1_JobSpec_To_batch_JobSpec(in *JobSpec, out *batch.JobSpec, s conversion.Scope) error {
-	out.Parallelism = in.Parallelism
-	out.Completions = in.Completions
-	out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
-	if in.Selector != nil {
-		in, out := &in.Selector, &out.Selector
-		*out = new(unversioned.LabelSelector)
-		if err := Convert_v1_LabelSelector_To_unversioned_LabelSelector(*in, *out, s); err != nil {
-			return err
-		}
-	} else {
-		out.Selector = nil
-	}
-	out.ManualSelector = in.ManualSelector
-	if err := api_v1.Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func autoConvert_batch_JobSpec_To_v1_JobSpec(in *batch.JobSpec, out *JobSpec, s conversion.Scope) error {
-	out.Parallelism = in.Parallelism
-	out.Completions = in.Completions
-	out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
-	if in.Selector != nil {
-		in, out := &in.Selector, &out.Selector
-		*out = new(LabelSelector)
-		if err := Convert_unversioned_LabelSelector_To_v1_LabelSelector(*in, *out, s); err != nil {
-			return err
-		}
-	} else {
-		out.Selector = nil
-	}
-	out.ManualSelector = in.ManualSelector
-	if err := api_v1.Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func autoConvert_v1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
-	if in.Conditions != nil {
-		in, out := &in.Conditions, &out.Conditions
-		*out = make([]batch.JobCondition, len(*in))
-		for i := range *in {
-			if err := Convert_v1_JobCondition_To_batch_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Conditions = nil
-	}
-	out.StartTime = in.StartTime
-	out.CompletionTime = in.CompletionTime
-	out.Active = in.Active
-	out.Succeeded = in.Succeeded
-	out.Failed = in.Failed
-	return nil
-}
-
-func Convert_v1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
-	return autoConvert_v1_JobStatus_To_batch_JobStatus(in, out, s)
-}
-
-func autoConvert_batch_JobStatus_To_v1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
-	if in.Conditions != nil {
-		in, out := &in.Conditions, &out.Conditions
-		*out = make([]JobCondition, len(*in))
-		for i := range *in {
-			if err := Convert_batch_JobCondition_To_v1_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Conditions = nil
-	}
-	out.StartTime = in.StartTime
-	out.CompletionTime = in.CompletionTime
-	out.Active = in.Active
-	out.Succeeded = in.Succeeded
-	out.Failed = in.Failed
-	return nil
-}
-
-func Convert_batch_JobStatus_To_v1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
-	return autoConvert_batch_JobStatus_To_v1_JobStatus(in, out, s)
-}
-
-func autoConvert_v1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
-	out.MatchLabels = in.MatchLabels
-	if in.MatchExpressions != nil {
-		in, out := &in.MatchExpressions, &out.MatchExpressions
-		*out = make([]unversioned.LabelSelectorRequirement, len(*in))
-		for i := range *in {
-			if err := Convert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.MatchExpressions = nil
-	}
-	return nil
-}
-
-func Convert_v1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
-	return autoConvert_v1_LabelSelector_To_unversioned_LabelSelector(in, out, s)
-}
-
-func autoConvert_unversioned_LabelSelector_To_v1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
-	out.MatchLabels = in.MatchLabels
-	if in.MatchExpressions != nil {
-		in, out := &in.MatchExpressions, &out.MatchExpressions
-		*out = make([]LabelSelectorRequirement, len(*in))
-		for i := range *in {
-			if err := Convert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.MatchExpressions = nil
-	}
-	return nil
-}
-
-func Convert_unversioned_LabelSelector_To_v1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
-	return autoConvert_unversioned_LabelSelector_To_v1_LabelSelector(in, out, s)
-}
-
-func autoConvert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
-	out.Key = in.Key
-	out.Operator = unversioned.LabelSelectorOperator(in.Operator)
-	out.Values = in.Values
-	return nil
-}
-
-func Convert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
-	return autoConvert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in, out, s)
-}
-
-func autoConvert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
-	out.Key = in.Key
-	out.Operator = LabelSelectorOperator(in.Operator)
-	out.Values = in.Values
-	return nil
-}
-
-func Convert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
-	return autoConvert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(in, out, s)
-}

1.4/pkg/apis/batch/v2alpha1/zz_generated.conversion.go

@@ -1,577 +0,0 @@
-// +build !ignore_autogenerated
-
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// This file was autogenerated by conversion-gen. Do not edit it manually!
-
-package v2alpha1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.4/pkg/api/v1"
-	batch "k8s.io/client-go/1.4/pkg/apis/batch"
-	conversion "k8s.io/client-go/1.4/pkg/conversion"
-	runtime "k8s.io/client-go/1.4/pkg/runtime"
-)
-
-func init() {
-	SchemeBuilder.Register(RegisterConversions)
-}
-
-// RegisterConversions adds conversion functions to the given scheme.
-// Public to allow building arbitrary schemes.
-func RegisterConversions(scheme *runtime.Scheme) error {
-	return scheme.AddGeneratedConversionFuncs(
-		Convert_v2alpha1_Job_To_batch_Job,
-		Convert_batch_Job_To_v2alpha1_Job,
-		Convert_v2alpha1_JobCondition_To_batch_JobCondition,
-		Convert_batch_JobCondition_To_v2alpha1_JobCondition,
-		Convert_v2alpha1_JobList_To_batch_JobList,
-		Convert_batch_JobList_To_v2alpha1_JobList,
-		Convert_v2alpha1_JobSpec_To_batch_JobSpec,
-		Convert_batch_JobSpec_To_v2alpha1_JobSpec,
-		Convert_v2alpha1_JobStatus_To_batch_JobStatus,
-		Convert_batch_JobStatus_To_v2alpha1_JobStatus,
-		Convert_v2alpha1_JobTemplate_To_batch_JobTemplate,
-		Convert_batch_JobTemplate_To_v2alpha1_JobTemplate,
-		Convert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec,
-		Convert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec,
-		Convert_v2alpha1_LabelSelector_To_unversioned_LabelSelector,
-		Convert_unversioned_LabelSelector_To_v2alpha1_LabelSelector,
-		Convert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement,
-		Convert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement,
-		Convert_v2alpha1_ScheduledJob_To_batch_ScheduledJob,
-		Convert_batch_ScheduledJob_To_v2alpha1_ScheduledJob,
-		Convert_v2alpha1_ScheduledJobList_To_batch_ScheduledJobList,
-		Convert_batch_ScheduledJobList_To_v2alpha1_ScheduledJobList,
-		Convert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec,
-		Convert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec,
-		Convert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus,
-		Convert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus,
-	)
-}
-
-func autoConvert_v2alpha1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
-	SetDefaults_Job(in)
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_v2alpha1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_v2alpha1_JobStatus_To_batch_JobStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_v2alpha1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
-	return autoConvert_v2alpha1_Job_To_batch_Job(in, out, s)
-}
-
-func autoConvert_batch_Job_To_v2alpha1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_batch_JobSpec_To_v2alpha1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_batch_JobStatus_To_v2alpha1_JobStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_batch_Job_To_v2alpha1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
-	return autoConvert_batch_Job_To_v2alpha1_Job(in, out, s)
-}
-
-func autoConvert_v2alpha1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
-	out.Type = batch.JobConditionType(in.Type)
-	out.Status = api.ConditionStatus(in.Status)
-	if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
-		return err
-	}
-	out.Reason = in.Reason
-	out.Message = in.Message
-	return nil
-}
-
-func Convert_v2alpha1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
-	return autoConvert_v2alpha1_JobCondition_To_batch_JobCondition(in, out, s)
-}
-
-func autoConvert_batch_JobCondition_To_v2alpha1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
-	out.Type = JobConditionType(in.Type)
-	out.Status = v1.ConditionStatus(in.Status)
-	if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
-		return err
-	}
-	out.Reason = in.Reason
-	out.Message = in.Message
-	return nil
-}
-
-func Convert_batch_JobCondition_To_v2alpha1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
-	return autoConvert_batch_JobCondition_To_v2alpha1_JobCondition(in, out, s)
-}
-
-func autoConvert_v2alpha1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]batch.Job, len(*in))
-		for i := range *in {
-			if err := Convert_v2alpha1_Job_To_batch_Job(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_v2alpha1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
-	return autoConvert_v2alpha1_JobList_To_batch_JobList(in, out, s)
-}
-
-func autoConvert_batch_JobList_To_v2alpha1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]Job, len(*in))
-		for i := range *in {
-			if err := Convert_batch_Job_To_v2alpha1_Job(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_batch_JobList_To_v2alpha1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
-	return autoConvert_batch_JobList_To_v2alpha1_JobList(in, out, s)
-}
-
-func autoConvert_v2alpha1_JobSpec_To_batch_JobSpec(in *JobSpec, out *batch.JobSpec, s conversion.Scope) error {
-	out.Parallelism = in.Parallelism
-	out.Completions = in.Completions
-	out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
-	if in.Selector != nil {
-		in, out := &in.Selector, &out.Selector
-		*out = new(unversioned.LabelSelector)
-		if err := Convert_v2alpha1_LabelSelector_To_unversioned_LabelSelector(*in, *out, s); err != nil {
-			return err
-		}
-	} else {
-		out.Selector = nil
-	}
-	out.ManualSelector = in.ManualSelector
-	if err := v1.Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func autoConvert_batch_JobSpec_To_v2alpha1_JobSpec(in *batch.JobSpec, out *JobSpec, s conversion.Scope) error {
-	out.Parallelism = in.Parallelism
-	out.Completions = in.Completions
-	out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
-	if in.Selector != nil {
-		in, out := &in.Selector, &out.Selector
-		*out = new(LabelSelector)
-		if err := Convert_unversioned_LabelSelector_To_v2alpha1_LabelSelector(*in, *out, s); err != nil {
-			return err
-		}
-	} else {
-		out.Selector = nil
-	}
-	out.ManualSelector = in.ManualSelector
-	if err := v1.Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func autoConvert_v2alpha1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
-	if in.Conditions != nil {
-		in, out := &in.Conditions, &out.Conditions
-		*out = make([]batch.JobCondition, len(*in))
-		for i := range *in {
-			if err := Convert_v2alpha1_JobCondition_To_batch_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Conditions = nil
-	}
-	out.StartTime = in.StartTime
-	out.CompletionTime = in.CompletionTime
-	out.Active = in.Active
-	out.Succeeded = in.Succeeded
-	out.Failed = in.Failed
-	return nil
-}
-
-func Convert_v2alpha1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
-	return autoConvert_v2alpha1_JobStatus_To_batch_JobStatus(in, out, s)
-}
-
-func autoConvert_batch_JobStatus_To_v2alpha1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
-	if in.Conditions != nil {
-		in, out := &in.Conditions, &out.Conditions
-		*out = make([]JobCondition, len(*in))
-		for i := range *in {
-			if err := Convert_batch_JobCondition_To_v2alpha1_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Conditions = nil
-	}
-	out.StartTime = in.StartTime
-	out.CompletionTime = in.CompletionTime
-	out.Active = in.Active
-	out.Succeeded = in.Succeeded
-	out.Failed = in.Failed
-	return nil
-}
-
-func Convert_batch_JobStatus_To_v2alpha1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
-	return autoConvert_batch_JobStatus_To_v2alpha1_JobStatus(in, out, s)
-}
-
-func autoConvert_v2alpha1_JobTemplate_To_batch_JobTemplate(in *JobTemplate, out *batch.JobTemplate, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(&in.Template, &out.Template, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_v2alpha1_JobTemplate_To_batch_JobTemplate(in *JobTemplate, out *batch.JobTemplate, s conversion.Scope) error {
-	return autoConvert_v2alpha1_JobTemplate_To_batch_JobTemplate(in, out, s)
-}
-
-func autoConvert_batch_JobTemplate_To_v2alpha1_JobTemplate(in *batch.JobTemplate, out *JobTemplate, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(&in.Template, &out.Template, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_batch_JobTemplate_To_v2alpha1_JobTemplate(in *batch.JobTemplate, out *JobTemplate, s conversion.Scope) error {
-	return autoConvert_batch_JobTemplate_To_v2alpha1_JobTemplate(in, out, s)
-}
-
-func autoConvert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(in *JobTemplateSpec, out *batch.JobTemplateSpec, s conversion.Scope) error {
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_v2alpha1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(in *JobTemplateSpec, out *batch.JobTemplateSpec, s conversion.Scope) error {
-	return autoConvert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(in, out, s)
-}
-
-func autoConvert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(in *batch.JobTemplateSpec, out *JobTemplateSpec, s conversion.Scope) error {
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_batch_JobSpec_To_v2alpha1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(in *batch.JobTemplateSpec, out *JobTemplateSpec, s conversion.Scope) error {
-	return autoConvert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(in, out, s)
-}
-
-func autoConvert_v2alpha1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
-	out.MatchLabels = in.MatchLabels
-	if in.MatchExpressions != nil {
-		in, out := &in.MatchExpressions, &out.MatchExpressions
-		*out = make([]unversioned.LabelSelectorRequirement, len(*in))
-		for i := range *in {
-			if err := Convert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.MatchExpressions = nil
-	}
-	return nil
-}
-
-func Convert_v2alpha1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
-	return autoConvert_v2alpha1_LabelSelector_To_unversioned_LabelSelector(in, out, s)
-}
-
-func autoConvert_unversioned_LabelSelector_To_v2alpha1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
-	out.MatchLabels = in.MatchLabels
-	if in.MatchExpressions != nil {
-		in, out := &in.MatchExpressions, &out.MatchExpressions
-		*out = make([]LabelSelectorRequirement, len(*in))
-		for i := range *in {
-			if err := Convert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.MatchExpressions = nil
-	}
-	return nil
-}
-
-func Convert_unversioned_LabelSelector_To_v2alpha1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
-	return autoConvert_unversioned_LabelSelector_To_v2alpha1_LabelSelector(in, out, s)
-}
-
-func autoConvert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
-	out.Key = in.Key
-	out.Operator = unversioned.LabelSelectorOperator(in.Operator)
-	out.Values = in.Values
-	return nil
-}
-
-func Convert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
-	return autoConvert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in, out, s)
-}
-
-func autoConvert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
-	out.Key = in.Key
-	out.Operator = LabelSelectorOperator(in.Operator)
-	out.Values = in.Values
-	return nil
-}
-
-func Convert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
-	return autoConvert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement(in, out, s)
-}
-
-func autoConvert_v2alpha1_ScheduledJob_To_batch_ScheduledJob(in *ScheduledJob, out *batch.ScheduledJob, s conversion.Scope) error {
-	SetDefaults_ScheduledJob(in)
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_v2alpha1_ScheduledJob_To_batch_ScheduledJob(in *ScheduledJob, out *batch.ScheduledJob, s conversion.Scope) error {
-	return autoConvert_v2alpha1_ScheduledJob_To_batch_ScheduledJob(in, out, s)
-}
-
-func autoConvert_batch_ScheduledJob_To_v2alpha1_ScheduledJob(in *batch.ScheduledJob, out *ScheduledJob, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_batch_ScheduledJob_To_v2alpha1_ScheduledJob(in *batch.ScheduledJob, out *ScheduledJob, s conversion.Scope) error {
-	return autoConvert_batch_ScheduledJob_To_v2alpha1_ScheduledJob(in, out, s)
-}
-
-func autoConvert_v2alpha1_ScheduledJobList_To_batch_ScheduledJobList(in *ScheduledJobList, out *batch.ScheduledJobList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]batch.ScheduledJob, len(*in))
-		for i := range *in {
-			if err := Convert_v2alpha1_ScheduledJob_To_batch_ScheduledJob(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_v2alpha1_ScheduledJobList_To_batch_ScheduledJobList(in *ScheduledJobList, out *batch.ScheduledJobList, s conversion.Scope) error {
-	return autoConvert_v2alpha1_ScheduledJobList_To_batch_ScheduledJobList(in, out, s)
-}
-
-func autoConvert_batch_ScheduledJobList_To_v2alpha1_ScheduledJobList(in *batch.ScheduledJobList, out *ScheduledJobList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]ScheduledJob, len(*in))
-		for i := range *in {
-			if err := Convert_batch_ScheduledJob_To_v2alpha1_ScheduledJob(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_batch_ScheduledJobList_To_v2alpha1_ScheduledJobList(in *batch.ScheduledJobList, out *ScheduledJobList, s conversion.Scope) error {
-	return autoConvert_batch_ScheduledJobList_To_v2alpha1_ScheduledJobList(in, out, s)
-}
-
-func autoConvert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec(in *ScheduledJobSpec, out *batch.ScheduledJobSpec, s conversion.Scope) error {
-	out.Schedule = in.Schedule
-	out.StartingDeadlineSeconds = in.StartingDeadlineSeconds
-	out.ConcurrencyPolicy = batch.ConcurrencyPolicy(in.ConcurrencyPolicy)
-	out.Suspend = in.Suspend
-	if err := Convert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(&in.JobTemplate, &out.JobTemplate, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec(in *ScheduledJobSpec, out *batch.ScheduledJobSpec, s conversion.Scope) error {
-	return autoConvert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec(in, out, s)
-}
-
-func autoConvert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec(in *batch.ScheduledJobSpec, out *ScheduledJobSpec, s conversion.Scope) error {
-	out.Schedule = in.Schedule
-	out.StartingDeadlineSeconds = in.StartingDeadlineSeconds
-	out.ConcurrencyPolicy = ConcurrencyPolicy(in.ConcurrencyPolicy)
-	out.Suspend = in.Suspend
-	if err := Convert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(&in.JobTemplate, &out.JobTemplate, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec(in *batch.ScheduledJobSpec, out *ScheduledJobSpec, s conversion.Scope) error {
-	return autoConvert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec(in, out, s)
-}
-
-func autoConvert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus(in *ScheduledJobStatus, out *batch.ScheduledJobStatus, s conversion.Scope) error {
-	if in.Active != nil {
-		in, out := &in.Active, &out.Active
-		*out = make([]api.ObjectReference, len(*in))
-		for i := range *in {
-			// TODO: Inefficient conversion - can we improve it?
-			if err := s.Convert(&(*in)[i], &(*out)[i], 0); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Active = nil
-	}
-	out.LastScheduleTime = in.LastScheduleTime
-	return nil
-}
-
-func Convert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus(in *ScheduledJobStatus, out *batch.ScheduledJobStatus, s conversion.Scope) error {
-	return autoConvert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus(in, out, s)
-}
-
-func autoConvert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus(in *batch.ScheduledJobStatus, out *ScheduledJobStatus, s conversion.Scope) error {
-	if in.Active != nil {
-		in, out := &in.Active, &out.Active
-		*out = make([]v1.ObjectReference, len(*in))
-		for i := range *in {
-			// TODO: Inefficient conversion - can we improve it?
-			if err := s.Convert(&(*in)[i], &(*out)[i], 0); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Active = nil
-	}
-	out.LastScheduleTime = in.LastScheduleTime
-	return nil
-}
-
-func Convert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus(in *batch.ScheduledJobStatus, out *ScheduledJobStatus, s conversion.Scope) error {
-	return autoConvert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus(in, out, s)
-}

1.4/pkg/apis/certificates/install/install.go

@@ -1,137 +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 install installs the certificates API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/certificates"
-	"k8s.io/client-go/1.4/pkg/apis/certificates/v1alpha1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/certificates"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", certificates.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions therecertificates
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	// the list of kinds that are scoped at the root of the api hierarchy
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
-	rootScoped := sets.NewString(
-		"CertificateSigningRequest",
-	)
-
-	ignoredKinds := sets.NewString()
-
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-// interfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1alpha1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(certificates.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := certificates.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1alpha1.SchemeGroupVersion:
-			if err := v1alpha1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.4/pkg/apis/componentconfig/install/install.go

@@ -1,135 +0,0 @@
-/*
-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 install installs the experimental API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/componentconfig"
-	"k8s.io/client-go/1.4/pkg/apis/componentconfig/v1alpha1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/componentconfig"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", componentconfig.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	// the list of kinds that are scoped at the root of the api hierarchy
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
-	rootScoped := sets.NewString()
-
-	ignoredKinds := sets.NewString()
-
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-// interfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1alpha1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(componentconfig.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := componentconfig.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1alpha1.SchemeGroupVersion:
-			if err := v1alpha1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.4/pkg/apis/extensions/install/install.go

@@ -1,139 +0,0 @@
-/*
-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 install installs the experimental API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/extensions"
-	"k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/extensions"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", extensions.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	// the list of kinds that are scoped at the root of the api hierarchy
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
-	rootScoped := sets.NewString(
-		"PodSecurityPolicy",
-		"ThirdPartyResource",
-		"StorageClass",
-	)
-
-	ignoredKinds := sets.NewString()
-
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-// interfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1beta1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(extensions.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := extensions.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1beta1.SchemeGroupVersion:
-			if err := v1beta1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.4/pkg/apis/imagepolicy/install/install.go

@@ -1,123 +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 install installs the experimental API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/imagepolicy"
-	"k8s.io/client-go/1.4/pkg/apis/imagepolicy/v1alpha1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/imagepolicy"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", imagepolicy.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	imagepolicy.AddToScheme(api.Scheme)
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1alpha1.SchemeGroupVersion:
-			v1alpha1.AddToScheme(api.Scheme)
-		}
-	}
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	rootScoped := sets.NewString("ImageReview")
-	ignoredKinds := sets.NewString()
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1alpha1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(imagepolicy.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}

1.4/pkg/apis/policy/install/install.go

@@ -1,135 +0,0 @@
-/*
-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 install installs the experimental API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/policy"
-	"k8s.io/client-go/1.4/pkg/apis/policy/v1alpha1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/policy"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", policy.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	// the list of kinds that are scoped at the root of the api hierarchy
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
-	rootScoped := sets.NewString()
-
-	ignoredKinds := sets.NewString()
-
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-// interfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1alpha1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(policy.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := policy.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1alpha1.SchemeGroupVersion:
-			if err := v1alpha1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.4/pkg/apis/policy/v1alpha1/zz_generated.conversion.go

@@ -1,240 +0,0 @@
-// +build !ignore_autogenerated
-
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// This file was autogenerated by conversion-gen. Do not edit it manually!
-
-package v1alpha1
-
-import (
-	api "k8s.io/client-go/1.4/pkg/api"
-	v1 "k8s.io/client-go/1.4/pkg/api/v1"
-	policy "k8s.io/client-go/1.4/pkg/apis/policy"
-	conversion "k8s.io/client-go/1.4/pkg/conversion"
-	runtime "k8s.io/client-go/1.4/pkg/runtime"
-)
-
-func init() {
-	SchemeBuilder.Register(RegisterConversions)
-}
-
-// RegisterConversions adds conversion functions to the given scheme.
-// Public to allow building arbitrary schemes.
-func RegisterConversions(scheme *runtime.Scheme) error {
-	return scheme.AddGeneratedConversionFuncs(
-		Convert_v1alpha1_Eviction_To_policy_Eviction,
-		Convert_policy_Eviction_To_v1alpha1_Eviction,
-		Convert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget,
-		Convert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget,
-		Convert_v1alpha1_PodDisruptionBudgetList_To_policy_PodDisruptionBudgetList,
-		Convert_policy_PodDisruptionBudgetList_To_v1alpha1_PodDisruptionBudgetList,
-		Convert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec,
-		Convert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec,
-		Convert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus,
-		Convert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus,
-	)
-}
-
-func autoConvert_v1alpha1_Eviction_To_policy_Eviction(in *Eviction, out *policy.Eviction, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if in.DeleteOptions != nil {
-		in, out := &in.DeleteOptions, &out.DeleteOptions
-		*out = new(api.DeleteOptions)
-		// TODO: Inefficient conversion - can we improve it?
-		if err := s.Convert(*in, *out, 0); err != nil {
-			return err
-		}
-	} else {
-		out.DeleteOptions = nil
-	}
-	return nil
-}
-
-func Convert_v1alpha1_Eviction_To_policy_Eviction(in *Eviction, out *policy.Eviction, s conversion.Scope) error {
-	return autoConvert_v1alpha1_Eviction_To_policy_Eviction(in, out, s)
-}
-
-func autoConvert_policy_Eviction_To_v1alpha1_Eviction(in *policy.Eviction, out *Eviction, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if in.DeleteOptions != nil {
-		in, out := &in.DeleteOptions, &out.DeleteOptions
-		*out = new(v1.DeleteOptions)
-		// TODO: Inefficient conversion - can we improve it?
-		if err := s.Convert(*in, *out, 0); err != nil {
-			return err
-		}
-	} else {
-		out.DeleteOptions = nil
-	}
-	return nil
-}
-
-func Convert_policy_Eviction_To_v1alpha1_Eviction(in *policy.Eviction, out *Eviction, s conversion.Scope) error {
-	return autoConvert_policy_Eviction_To_v1alpha1_Eviction(in, out, s)
-}
-
-func autoConvert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget(in *PodDisruptionBudget, out *policy.PodDisruptionBudget, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget(in *PodDisruptionBudget, out *policy.PodDisruptionBudget, s conversion.Scope) error {
-	return autoConvert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget(in, out, s)
-}
-
-func autoConvert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget(in *policy.PodDisruptionBudget, out *PodDisruptionBudget, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	// TODO: Inefficient conversion - can we improve it?
-	if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
-		return err
-	}
-	if err := Convert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec(&in.Spec, &out.Spec, s); err != nil {
-		return err
-	}
-	if err := Convert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus(&in.Status, &out.Status, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Convert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget(in *policy.PodDisruptionBudget, out *PodDisruptionBudget, s conversion.Scope) error {
-	return autoConvert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget(in, out, s)
-}
-
-func autoConvert_v1alpha1_PodDisruptionBudgetList_To_policy_PodDisruptionBudgetList(in *PodDisruptionBudgetList, out *policy.PodDisruptionBudgetList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]policy.PodDisruptionBudget, len(*in))
-		for i := range *in {
-			if err := Convert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_v1alpha1_PodDisruptionBudgetList_To_policy_PodDisruptionBudgetList(in *PodDisruptionBudgetList, out *policy.PodDisruptionBudgetList, s conversion.Scope) error {
-	return autoConvert_v1alpha1_PodDisruptionBudgetList_To_policy_PodDisruptionBudgetList(in, out, s)
-}
-
-func autoConvert_policy_PodDisruptionBudgetList_To_v1alpha1_PodDisruptionBudgetList(in *policy.PodDisruptionBudgetList, out *PodDisruptionBudgetList, s conversion.Scope) error {
-	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
-		return err
-	}
-	if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
-		return err
-	}
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]PodDisruptionBudget, len(*in))
-		for i := range *in {
-			if err := Convert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
-	return nil
-}
-
-func Convert_policy_PodDisruptionBudgetList_To_v1alpha1_PodDisruptionBudgetList(in *policy.PodDisruptionBudgetList, out *PodDisruptionBudgetList, s conversion.Scope) error {
-	return autoConvert_policy_PodDisruptionBudgetList_To_v1alpha1_PodDisruptionBudgetList(in, out, s)
-}
-
-func autoConvert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec(in *PodDisruptionBudgetSpec, out *policy.PodDisruptionBudgetSpec, s conversion.Scope) error {
-	if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.MinAvailable, &out.MinAvailable, s); err != nil {
-		return err
-	}
-	out.Selector = in.Selector
-	return nil
-}
-
-func Convert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec(in *PodDisruptionBudgetSpec, out *policy.PodDisruptionBudgetSpec, s conversion.Scope) error {
-	return autoConvert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec(in, out, s)
-}
-
-func autoConvert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec(in *policy.PodDisruptionBudgetSpec, out *PodDisruptionBudgetSpec, s conversion.Scope) error {
-	if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.MinAvailable, &out.MinAvailable, s); err != nil {
-		return err
-	}
-	out.Selector = in.Selector
-	return nil
-}
-
-func Convert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec(in *policy.PodDisruptionBudgetSpec, out *PodDisruptionBudgetSpec, s conversion.Scope) error {
-	return autoConvert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec(in, out, s)
-}
-
-func autoConvert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus(in *PodDisruptionBudgetStatus, out *policy.PodDisruptionBudgetStatus, s conversion.Scope) error {
-	out.PodDisruptionAllowed = in.PodDisruptionAllowed
-	out.CurrentHealthy = in.CurrentHealthy
-	out.DesiredHealthy = in.DesiredHealthy
-	out.ExpectedPods = in.ExpectedPods
-	return nil
-}
-
-func Convert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus(in *PodDisruptionBudgetStatus, out *policy.PodDisruptionBudgetStatus, s conversion.Scope) error {
-	return autoConvert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus(in, out, s)
-}
-
-func autoConvert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus(in *policy.PodDisruptionBudgetStatus, out *PodDisruptionBudgetStatus, s conversion.Scope) error {
-	out.PodDisruptionAllowed = in.PodDisruptionAllowed
-	out.CurrentHealthy = in.CurrentHealthy
-	out.DesiredHealthy = in.DesiredHealthy
-	out.ExpectedPods = in.ExpectedPods
-	return nil
-}
-
-func Convert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus(in *policy.PodDisruptionBudgetStatus, out *PodDisruptionBudgetStatus, s conversion.Scope) error {
-	return autoConvert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus(in, out, s)
-}

1.4/pkg/apis/rbac/install/install.go

@@ -1,136 +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 install installs the batch API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/rbac"
-	"k8s.io/client-go/1.4/pkg/apis/rbac/v1alpha1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/rbac"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", rbac.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	rootScoped := sets.NewString(
-		"ClusterRole",
-		"ClusterRoleBinding",
-	)
-
-	ignoredKinds := sets.NewString()
-
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-// interfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1alpha1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(rbac.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := rbac.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1alpha1.SchemeGroupVersion:
-			if err := v1alpha1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.4/pkg/apis/storage/install/install.go

@@ -1,137 +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 install installs the experimental API group, making it available as
-// an option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apimachinery"
-	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.4/pkg/apis/storage"
-	"k8s.io/client-go/1.4/pkg/apis/storage/v1beta1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.4/pkg/apis/storage"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", storage.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	api.RegisterRESTMapper(groupMeta.RESTMapper)
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	// the list of kinds that are scoped at the root of the api hierarchy
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
-	rootScoped := sets.NewString(
-		"StorageClass",
-	)
-
-	ignoredKinds := sets.NewString()
-
-	return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-}
-
-// interfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1beta1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(storage.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := storage.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1beta1.SchemeGroupVersion:
-			if err := v1beta1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.4/pkg/capabilities/capabilities.go

@@ -1,94 +0,0 @@
-/*
-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 capabilities
-
-import (
-	"sync"
-)
-
-// Capabilities defines the set of capabilities available within the system.
-// For now these are global.  Eventually they may be per-user
-type Capabilities struct {
-	AllowPrivileged bool
-
-	// Pod sources from which to allow privileged capabilities like host networking, sharing the host
-	// IPC namespace, and sharing the host PID namespace.
-	PrivilegedSources PrivilegedSources
-
-	// PerConnectionBandwidthLimitBytesPerSec limits the throughput of each connection (currently only used for proxy, exec, attach)
-	PerConnectionBandwidthLimitBytesPerSec int64
-}
-
-// PrivilegedSources defines the pod sources allowed to make privileged requests for certain types
-// of capabilities like host networking, sharing the host IPC namespace, and sharing the host PID namespace.
-type PrivilegedSources struct {
-	// List of pod sources for which using host network is allowed.
-	HostNetworkSources []string
-
-	// List of pod sources for which using host pid namespace is allowed.
-	HostPIDSources []string
-
-	// List of pod sources for which using host ipc is allowed.
-	HostIPCSources []string
-}
-
-// TODO: Clean these up into a singleton
-var once sync.Once
-var lock sync.Mutex
-var capabilities *Capabilities
-
-// Initialize the capability set.  This can only be done once per binary, subsequent calls are ignored.
-func Initialize(c Capabilities) {
-	// Only do this once
-	once.Do(func() {
-		capabilities = &c
-	})
-}
-
-// Setup the capability set.  It wraps Initialize for improving usability.
-func Setup(allowPrivileged bool, privilegedSources PrivilegedSources, perConnectionBytesPerSec int64) {
-	Initialize(Capabilities{
-		AllowPrivileged:                        allowPrivileged,
-		PrivilegedSources:                      privilegedSources,
-		PerConnectionBandwidthLimitBytesPerSec: perConnectionBytesPerSec,
-	})
-}
-
-// SetCapabilitiesForTests.  Convenience method for testing.  This should only be called from tests.
-func SetForTests(c Capabilities) {
-	lock.Lock()
-	defer lock.Unlock()
-	capabilities = &c
-}
-
-// Returns a read-only copy of the system capabilities.
-func Get() Capabilities {
-	lock.Lock()
-	defer lock.Unlock()
-	// This check prevents clobbering of capabilities that might've been set via SetForTests
-	if capabilities == nil {
-		Initialize(Capabilities{
-			AllowPrivileged: false,
-			PrivilegedSources: PrivilegedSources{
-				HostNetworkSources: []string{},
-				HostPIDSources:     []string{},
-				HostIPCSources:     []string{},
-			},
-		})
-	}
-	return *capabilities
-}

1.4/pkg/capabilities/doc.go

@@ -1,18 +0,0 @@
-/*
-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 capabilities manages system level capabilities
-package capabilities

1.4/pkg/runtime/serializer/negotiated_codec.go

@@ -1,56 +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 serializer
-
-import (
-	"k8s.io/client-go/1.4/pkg/runtime"
-)
-
-// TODO: We should figure out what happens when someone asks
-// encoder for version and it conflicts with the raw serializer.
-type negotiatedSerializerWrapper struct {
-	info       runtime.SerializerInfo
-	streamInfo runtime.StreamSerializerInfo
-}
-
-func NegotiatedSerializerWrapper(info runtime.SerializerInfo, streamInfo runtime.StreamSerializerInfo) runtime.NegotiatedSerializer {
-	return &negotiatedSerializerWrapper{info, streamInfo}
-}
-
-func (n *negotiatedSerializerWrapper) SupportedMediaTypes() []string {
-	return []string{}
-}
-
-func (n *negotiatedSerializerWrapper) SerializerForMediaType(mediaType string, options map[string]string) (runtime.SerializerInfo, bool) {
-	return n.info, true
-}
-
-func (n *negotiatedSerializerWrapper) SupportedStreamingMediaTypes() []string {
-	return []string{}
-}
-
-func (n *negotiatedSerializerWrapper) StreamingSerializerForMediaType(mediaType string, options map[string]string) (runtime.StreamSerializerInfo, bool) {
-	return n.streamInfo, true
-}
-
-func (n *negotiatedSerializerWrapper) EncoderForVersion(e runtime.Encoder, _ runtime.GroupVersioner) runtime.Encoder {
-	return e
-}
-
-func (n *negotiatedSerializerWrapper) DecoderToVersion(d runtime.Decoder, _gv runtime.GroupVersioner) runtime.Decoder {
-	return d
-}

1.4/pkg/runtime/unstructured.go

@@ -1,204 +0,0 @@
-/*
-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 runtime
-
-import (
-	gojson "encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/util/json"
-)
-
-// UnstructuredJSONScheme is capable of converting JSON data into the Unstructured
-// type, which can be used for generic access to objects without a predefined scheme.
-// TODO: move into serializer/json.
-var UnstructuredJSONScheme Codec = unstructuredJSONScheme{}
-
-type unstructuredJSONScheme struct{}
-
-func (s unstructuredJSONScheme) Decode(data []byte, _ *unversioned.GroupVersionKind, obj Object) (Object, *unversioned.GroupVersionKind, error) {
-	var err error
-	if obj != nil {
-		err = s.decodeInto(data, obj)
-	} else {
-		obj, err = s.decode(data)
-	}
-
-	if err != nil {
-		return nil, nil, err
-	}
-
-	gvk := obj.GetObjectKind().GroupVersionKind()
-	if len(gvk.Kind) == 0 {
-		return nil, &gvk, NewMissingKindErr(string(data))
-	}
-
-	return obj, &gvk, nil
-}
-
-func (unstructuredJSONScheme) Encode(obj Object, w io.Writer) error {
-	switch t := obj.(type) {
-	case *Unstructured:
-		return json.NewEncoder(w).Encode(t.Object)
-	case *UnstructuredList:
-		items := make([]map[string]interface{}, 0, len(t.Items))
-		for _, i := range t.Items {
-			items = append(items, i.Object)
-		}
-		t.Object["items"] = items
-		defer func() { delete(t.Object, "items") }()
-		return json.NewEncoder(w).Encode(t.Object)
-	case *Unknown:
-		// TODO: Unstructured needs to deal with ContentType.
-		_, err := w.Write(t.Raw)
-		return err
-	default:
-		return json.NewEncoder(w).Encode(t)
-	}
-}
-
-func (s unstructuredJSONScheme) decode(data []byte) (Object, error) {
-	type detector struct {
-		Items gojson.RawMessage
-	}
-	var det detector
-	if err := json.Unmarshal(data, &det); err != nil {
-		return nil, err
-	}
-
-	if det.Items != nil {
-		list := &UnstructuredList{}
-		err := s.decodeToList(data, list)
-		return list, err
-	}
-
-	// No Items field, so it wasn't a list.
-	unstruct := &Unstructured{}
-	err := s.decodeToUnstructured(data, unstruct)
-	return unstruct, err
-}
-
-func (s unstructuredJSONScheme) decodeInto(data []byte, obj Object) error {
-	switch x := obj.(type) {
-	case *Unstructured:
-		return s.decodeToUnstructured(data, x)
-	case *UnstructuredList:
-		return s.decodeToList(data, x)
-	case *VersionedObjects:
-		o, err := s.decode(data)
-		if err == nil {
-			x.Objects = []Object{o}
-		}
-		return err
-	default:
-		return json.Unmarshal(data, x)
-	}
-}
-
-func (unstructuredJSONScheme) decodeToUnstructured(data []byte, unstruct *Unstructured) error {
-	m := make(map[string]interface{})
-	if err := json.Unmarshal(data, &m); err != nil {
-		return err
-	}
-
-	unstruct.Object = m
-
-	return nil
-}
-
-func (s unstructuredJSONScheme) decodeToList(data []byte, list *UnstructuredList) error {
-	type decodeList struct {
-		Items []gojson.RawMessage
-	}
-
-	var dList decodeList
-	if err := json.Unmarshal(data, &dList); err != nil {
-		return err
-	}
-
-	if err := json.Unmarshal(data, &list.Object); err != nil {
-		return err
-	}
-
-	// For typed lists, e.g., a PodList, API server doesn't set each item's
-	// APIVersion and Kind. We need to set it.
-	listAPIVersion := list.GetAPIVersion()
-	listKind := list.GetKind()
-	itemKind := strings.TrimSuffix(listKind, "List")
-
-	delete(list.Object, "items")
-	list.Items = nil
-	for _, i := range dList.Items {
-		unstruct := &Unstructured{}
-		if err := s.decodeToUnstructured([]byte(i), unstruct); err != nil {
-			return err
-		}
-		// This is hacky. Set the item's Kind and APIVersion to those inferred
-		// from the List.
-		if len(unstruct.GetKind()) == 0 && len(unstruct.GetAPIVersion()) == 0 {
-			unstruct.SetKind(itemKind)
-			unstruct.SetAPIVersion(listAPIVersion)
-		}
-		list.Items = append(list.Items, unstruct)
-	}
-	return nil
-}
-
-// UnstructuredObjectConverter is an ObjectConverter for use with
-// Unstructured objects. Since it has no schema or type information,
-// it will only succeed for no-op conversions. This is provided as a
-// sane implementation for APIs that require an object converter.
-type UnstructuredObjectConverter struct{}
-
-func (UnstructuredObjectConverter) Convert(in, out, context interface{}) error {
-	unstructIn, ok := in.(*Unstructured)
-	if !ok {
-		return fmt.Errorf("input type %T in not valid for unstructured conversion", in)
-	}
-
-	unstructOut, ok := out.(*Unstructured)
-	if !ok {
-		return fmt.Errorf("output type %T in not valid for unstructured conversion", out)
-	}
-
-	// maybe deep copy the map? It is documented in the
-	// ObjectConverter interface that this function is not
-	// guaranteeed to not mutate the input. Or maybe set the input
-	// object to nil.
-	unstructOut.Object = unstructIn.Object
-	return nil
-}
-
-func (UnstructuredObjectConverter) ConvertToVersion(in Object, target GroupVersioner) (Object, error) {
-	if kind := in.GetObjectKind().GroupVersionKind(); !kind.Empty() {
-		gvk, ok := target.KindForGroupVersionKinds([]unversioned.GroupVersionKind{kind})
-		if !ok {
-			// TODO: should this be a typed error?
-			return nil, fmt.Errorf("%v is unstructured and is not suitable for converting to %q", kind, target)
-		}
-		in.GetObjectKind().SetGroupVersionKind(gvk)
-	}
-	return in, nil
-}
-
-func (UnstructuredObjectConverter) ConvertFieldLabel(version, kind, label, value string) (string, string, error) {
-	return "", "", errors.New("unstructured cannot convert field labels")
-}

1.4/pkg/security/apparmor/helpers.go

@@ -1,62 +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 apparmor
-
-import (
-	"strings"
-
-	"k8s.io/client-go/1.4/pkg/api"
-)
-
-// TODO: Move these values into the API package.
-const (
-	// The prefix to an annotation key specifying a container profile.
-	ContainerAnnotationKeyPrefix = "container.apparmor.security.beta.kubernetes.io/"
-	// The annotation key specifying the default AppArmor profile.
-	DefaultProfileAnnotationKey = "apparmor.security.beta.kubernetes.io/defaultProfileName"
-	// The annotation key specifying the allowed AppArmor profiles.
-	AllowedProfilesAnnotationKey = "apparmor.security.beta.kubernetes.io/allowedProfileNames"
-
-	// The profile specifying the runtime default.
-	ProfileRuntimeDefault = "runtime/default"
-	// The prefix for specifying profiles loaded on the node.
-	ProfileNamePrefix = "localhost/"
-)
-
-// Checks whether app armor is required for pod to be run.
-func isRequired(pod *api.Pod) bool {
-	for key := range pod.Annotations {
-		if strings.HasPrefix(key, ContainerAnnotationKeyPrefix) {
-			return true
-		}
-	}
-	return false
-}
-
-// Returns the name of the profile to use with the container.
-func GetProfileName(pod *api.Pod, containerName string) string {
-	return pod.Annotations[ContainerAnnotationKeyPrefix+containerName]
-}
-
-// Sets the name of the profile to use with the container.
-func SetProfileName(pod *api.Pod, containerName, profileName string) error {
-	if pod.Annotations == nil {
-		pod.Annotations = map[string]string{}
-	}
-	pod.Annotations[ContainerAnnotationKeyPrefix+containerName] = profileName
-	return nil
-}

1.4/pkg/security/apparmor/validate.go

@@ -1,227 +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 apparmor
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"strings"
-
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/util"
-	utilconfig "k8s.io/client-go/1.4/pkg/util/config"
-)
-
-// Whether AppArmor should be disabled by default.
-// Set to true if the wrong build tags are set (see validate_disabled.go).
-var isDisabledBuild bool
-
-// Interface for validating that a pod with with an AppArmor profile can be run by a Node.
-type Validator interface {
-	Validate(pod *api.Pod) error
-	ValidateHost() error
-}
-
-func NewValidator(runtime string) Validator {
-	if err := validateHost(runtime); err != nil {
-		return &validator{validateHostErr: err}
-	}
-	appArmorFS, err := getAppArmorFS()
-	if err != nil {
-		return &validator{
-			validateHostErr: fmt.Errorf("error finding AppArmor FS: %v", err),
-		}
-	}
-	return &validator{
-		appArmorFS: appArmorFS,
-	}
-}
-
-type validator struct {
-	validateHostErr error
-	appArmorFS      string
-}
-
-func (v *validator) Validate(pod *api.Pod) error {
-	if !isRequired(pod) {
-		return nil
-	}
-
-	if v.ValidateHost() != nil {
-		return v.validateHostErr
-	}
-
-	loadedProfiles, err := v.getLoadedProfiles()
-	if err != nil {
-		return fmt.Errorf("could not read loaded profiles: %v", err)
-	}
-
-	for _, container := range pod.Spec.InitContainers {
-		if err := validateProfile(GetProfileName(pod, container.Name), loadedProfiles); err != nil {
-			return err
-		}
-	}
-	for _, container := range pod.Spec.Containers {
-		if err := validateProfile(GetProfileName(pod, container.Name), loadedProfiles); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (v *validator) ValidateHost() error {
-	return v.validateHostErr
-}
-
-// Verify that the host and runtime is capable of enforcing AppArmor profiles.
-func validateHost(runtime string) error {
-	// Check feature-gates
-	if !utilconfig.DefaultFeatureGate.AppArmor() {
-		return errors.New("AppArmor disabled by feature-gate")
-	}
-
-	// Check build support.
-	if isDisabledBuild {
-		return errors.New("Binary not compiled for linux")
-	}
-
-	// Check kernel support.
-	if !IsAppArmorEnabled() {
-		return errors.New("AppArmor is not enabled on the host")
-	}
-
-	// Check runtime support. Currently only Docker is supported.
-	if runtime != "docker" {
-		return fmt.Errorf("AppArmor is only enabled for 'docker' runtime. Found: %q.", runtime)
-	}
-
-	return nil
-}
-
-// Verify that the profile is valid and loaded.
-func validateProfile(profile string, loadedProfiles map[string]bool) error {
-	if err := ValidateProfileFormat(profile); err != nil {
-		return err
-	}
-
-	if strings.HasPrefix(profile, ProfileNamePrefix) {
-		profileName := strings.TrimPrefix(profile, ProfileNamePrefix)
-		if !loadedProfiles[profileName] {
-			return fmt.Errorf("profile %q is not loaded", profileName)
-		}
-	}
-
-	return nil
-}
-
-func ValidateProfileFormat(profile string) error {
-	if profile == "" || profile == ProfileRuntimeDefault {
-		return nil
-	}
-	if !strings.HasPrefix(profile, ProfileNamePrefix) {
-		return fmt.Errorf("invalid AppArmor profile name: %q", profile)
-	}
-	return nil
-}
-
-func (v *validator) getLoadedProfiles() (map[string]bool, error) {
-	profilesPath := path.Join(v.appArmorFS, "profiles")
-	profilesFile, err := os.Open(profilesPath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open %s: %v", profilesPath, err)
-	}
-	defer profilesFile.Close()
-
-	profiles := map[string]bool{}
-	scanner := bufio.NewScanner(profilesFile)
-	for scanner.Scan() {
-		profileName := parseProfileName(scanner.Text())
-		if profileName == "" {
-			// Unknown line format; skip it.
-			continue
-		}
-		profiles[profileName] = true
-	}
-	return profiles, nil
-}
-
-// The profiles file is formatted with one profile per line, matching a form:
-//   namespace://profile-name (mode)
-//   profile-name (mode)
-// Where mode is {enforce, complain, kill}. The "namespace://" is only included for namespaced
-// profiles. For the purposes of Kubernetes, we consider the namespace part of the profile name.
-func parseProfileName(profileLine string) string {
-	modeIndex := strings.IndexRune(profileLine, '(')
-	if modeIndex < 0 {
-		return ""
-	}
-	return strings.TrimSpace(profileLine[:modeIndex])
-}
-
-func getAppArmorFS() (string, error) {
-	mountsFile, err := os.Open("/proc/mounts")
-	if err != nil {
-		return "", fmt.Errorf("could not open /proc/mounts: %v", err)
-	}
-	defer mountsFile.Close()
-
-	scanner := bufio.NewScanner(mountsFile)
-	for scanner.Scan() {
-		fields := strings.Fields(scanner.Text())
-		if len(fields) < 3 {
-			// Unknown line format; skip it.
-			continue
-		}
-		if fields[2] == "securityfs" {
-			appArmorFS := path.Join(fields[1], "apparmor")
-			if ok, err := util.FileExists(appArmorFS); !ok {
-				msg := fmt.Sprintf("path %s does not exist", appArmorFS)
-				if err != nil {
-					return "", fmt.Errorf("%s: %v", msg, err)
-				} else {
-					return "", errors.New(msg)
-				}
-			} else {
-				return appArmorFS, nil
-			}
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		return "", fmt.Errorf("error scanning mounts: %v", err)
-	}
-
-	return "", errors.New("securityfs not found")
-}
-
-// IsAppArmorEnabled returns true if apparmor is enabled for the host.
-// This function is forked from
-// https://github.com/opencontainers/runc/blob/1a81e9ab1f138c091fe5c86d0883f87716088527/libcontainer/apparmor/apparmor.go
-// to avoid the libapparmor dependency.
-func IsAppArmorEnabled() bool {
-	if _, err := os.Stat("/sys/kernel/security/apparmor"); err == nil && os.Getenv("container") == "" {
-		if _, err = os.Stat("/sbin/apparmor_parser"); err == nil {
-			buf, err := ioutil.ReadFile("/sys/module/apparmor/parameters/enabled")
-			return err == nil && len(buf) > 1 && buf[0] == 'Y'
-		}
-	}
-	return false
-}

1.4/pkg/util/crypto/crypto.go

@@ -1,212 +0,0 @@
-/*
-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 crypto
-
-import (
-	"bytes"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"math/big"
-	"net"
-	"os"
-	"path/filepath"
-	"time"
-)
-
-// FoundCertOrKey returns true if the certificate or key files already exists,
-// otherwise returns false.
-func FoundCertOrKey(certPath, keyPath string) bool {
-	if canReadFile(certPath) || canReadFile(keyPath) {
-		return true
-	}
-
-	return false
-}
-
-// If the file represented by path exists and
-// readable, returns true otherwise returns false.
-func canReadFile(path string) bool {
-	f, err := os.Open(path)
-	if err != nil {
-		return false
-	}
-
-	defer f.Close()
-
-	return true
-}
-
-// GenerateSelfSignedCert creates a self-signed certificate and key for the given host.
-// Host may be an IP or a DNS name
-// You may also specify additional subject alt names (either ip or dns names) for the certificate
-// The certificate will be created with file mode 0644. The key will be created with file mode 0600.
-// If the certificate or key files already exist, they will be overwritten.
-// Any parent directories of the certPath or keyPath will be created as needed with file mode 0755.
-func GenerateSelfSignedCert(host, certPath, keyPath string, alternateIPs []net.IP, alternateDNS []string) error {
-	priv, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		return err
-	}
-
-	template := x509.Certificate{
-		SerialNumber: big.NewInt(1),
-		Subject: pkix.Name{
-			CommonName: fmt.Sprintf("%s@%d", host, time.Now().Unix()),
-		},
-		NotBefore: time.Now(),
-		NotAfter:  time.Now().Add(time.Hour * 24 * 365),
-
-		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		BasicConstraintsValid: true,
-		IsCA: true,
-	}
-
-	if ip := net.ParseIP(host); ip != nil {
-		template.IPAddresses = append(template.IPAddresses, ip)
-	} else {
-		template.DNSNames = append(template.DNSNames, host)
-	}
-
-	template.IPAddresses = append(template.IPAddresses, alternateIPs...)
-	template.DNSNames = append(template.DNSNames, alternateDNS...)
-
-	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
-	if err != nil {
-		return err
-	}
-
-	// Generate cert
-	certBuffer := bytes.Buffer{}
-	if err := pem.Encode(&certBuffer, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
-		return err
-	}
-
-	// Generate key
-	keyBuffer := bytes.Buffer{}
-	if err := pem.Encode(&keyBuffer, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)}); err != nil {
-		return err
-	}
-
-	// Write cert
-	if err := WriteCertToPath(certPath, certBuffer.Bytes()); err != nil {
-		return err
-	}
-
-	// Write key
-	if err := WriteKeyToPath(keyPath, keyBuffer.Bytes()); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// WriteCertToPath writes the pem-encoded certificate data to certPath.
-// The certificate file will be created with file mode 0644.
-// If the certificate file already exists, it will be overwritten.
-// The parent directory of the certPath will be created as needed with file mode 0755.
-func WriteCertToPath(certPath string, data []byte) error {
-	if err := os.MkdirAll(filepath.Dir(certPath), os.FileMode(0755)); err != nil {
-		return err
-	}
-	if err := ioutil.WriteFile(certPath, data, os.FileMode(0644)); err != nil {
-		return err
-	}
-	return nil
-}
-
-// WriteKeyToPath writes the pem-encoded key data to keyPath.
-// The key file will be created with file mode 0600.
-// If the key file already exists, it will be overwritten.
-// The parent directory of the keyPath will be created as needed with file mode 0755.
-func WriteKeyToPath(keyPath string, data []byte) error {
-	if err := os.MkdirAll(filepath.Dir(keyPath), os.FileMode(0755)); err != nil {
-		return err
-	}
-	if err := ioutil.WriteFile(keyPath, data, os.FileMode(0600)); err != nil {
-		return err
-	}
-	return nil
-}
-
-// CertPoolFromFile returns an x509.CertPool containing the certificates in the given PEM-encoded file.
-// Returns an error if the file could not be read, a certificate could not be parsed, or if the file does not contain any certificates
-func CertPoolFromFile(filename string) (*x509.CertPool, error) {
-	certs, err := certificatesFromFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	pool := x509.NewCertPool()
-	for _, cert := range certs {
-		pool.AddCert(cert)
-	}
-	return pool, nil
-}
-
-// certificatesFromFile returns the x509.Certificates contained in the given PEM-encoded file.
-// Returns an error if the file could not be read, a certificate could not be parsed, or if the file does not contain any certificates
-func certificatesFromFile(file string) ([]*x509.Certificate, error) {
-	if len(file) == 0 {
-		return nil, errors.New("error reading certificates from an empty filename")
-	}
-	pemBlock, err := ioutil.ReadFile(file)
-	if err != nil {
-		return nil, err
-	}
-	certs, err := CertsFromPEM(pemBlock)
-	if err != nil {
-		return nil, fmt.Errorf("error reading %s: %s", file, err)
-	}
-	return certs, nil
-}
-
-// CertsFromPEM returns the x509.Certificates contained in the given PEM-encoded byte array
-// Returns an error if a certificate could not be parsed, or if the data does not contain any certificates
-func CertsFromPEM(pemCerts []byte) ([]*x509.Certificate, error) {
-	ok := false
-	certs := []*x509.Certificate{}
-	for len(pemCerts) > 0 {
-		var block *pem.Block
-		block, pemCerts = pem.Decode(pemCerts)
-		if block == nil {
-			break
-		}
-		// Only use PEM "CERTIFICATE" blocks without extra headers
-		if block.Type != "CERTIFICATE" || len(block.Headers) != 0 {
-			continue
-		}
-
-		cert, err := x509.ParseCertificate(block.Bytes)
-		if err != nil {
-			return certs, err
-		}
-
-		certs = append(certs, cert)
-		ok = true
-	}
-
-	if !ok {
-		return certs, errors.New("could not read any certificates")
-	}
-	return certs, nil
-}

1.4/pkg/util/hash/hash.go

@@ -1,37 +0,0 @@
-/*
-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 hash
-
-import (
-	"hash"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-// DeepHashObject writes specified object to hash using the spew library
-// which follows pointers and prints actual values of the nested objects
-// ensuring the hash does not change when a pointer changes.
-func DeepHashObject(hasher hash.Hash, objectToWrite interface{}) {
-	hasher.Reset()
-	printer := spew.ConfigState{
-		Indent:         " ",
-		SortKeys:       true,
-		DisableMethods: true,
-		SpewKeys:       true,
-	}
-	printer.Fprintf(hasher, "%#v", objectToWrite)
-}

1.4/pkg/util/net/sets/doc.go

@@ -1,28 +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.
-*/
-
-// This package contains hand-coded set implementations that should be similar
-// to the autogenerated ones in pkg/util/sets.
-// We can't simply use net.IPNet as a map-key in Go (because it contains a
-// []byte).
-// We could use the same workaround we use here (a string representation as the
-// key) to autogenerate sets.  If we do that, or decide on an alternate
-// approach, we should replace the implementations in this package with the
-// autogenerated versions.
-// It is expected that callers will alias this import as "netsets" i.e. import
-// netsets "k8s.io/client-go/1.4/pkg/util/net/sets"
-
-package sets

1.4/pkg/util/net/sets/ipnet.go

@@ -1,119 +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 sets
-
-import (
-	"net"
-	"strings"
-)
-
-type IPNet map[string]*net.IPNet
-
-func ParseIPNets(specs ...string) (IPNet, error) {
-	ipnetset := make(IPNet)
-	for _, spec := range specs {
-		spec = strings.TrimSpace(spec)
-		_, ipnet, err := net.ParseCIDR(spec)
-		if err != nil {
-			return nil, err
-		}
-		k := ipnet.String() // In case of normalization
-		ipnetset[k] = ipnet
-	}
-	return ipnetset, nil
-}
-
-// Insert adds items to the set.
-func (s IPNet) Insert(items ...*net.IPNet) {
-	for _, item := range items {
-		s[item.String()] = item
-	}
-}
-
-// Delete removes all items from the set.
-func (s IPNet) Delete(items ...*net.IPNet) {
-	for _, item := range items {
-		delete(s, item.String())
-	}
-}
-
-// Has returns true if and only if item is contained in the set.
-func (s IPNet) Has(item *net.IPNet) bool {
-	_, contained := s[item.String()]
-	return contained
-}
-
-// HasAll returns true if and only if all items are contained in the set.
-func (s IPNet) HasAll(items ...*net.IPNet) bool {
-	for _, item := range items {
-		if !s.Has(item) {
-			return false
-		}
-	}
-	return true
-}
-
-// Difference returns a set of objects that are not in s2
-// For example:
-// s1 = {a1, a2, a3}
-// s2 = {a1, a2, a4, a5}
-// s1.Difference(s2) = {a3}
-// s2.Difference(s1) = {a4, a5}
-func (s IPNet) Difference(s2 IPNet) IPNet {
-	result := make(IPNet)
-	for k, i := range s {
-		_, found := s2[k]
-		if found {
-			continue
-		}
-		result[k] = i
-	}
-	return result
-}
-
-// StringSlice returns a []string with the String representation of each element in the set.
-// Order is undefined.
-func (s IPNet) StringSlice() []string {
-	a := make([]string, 0, len(s))
-	for k := range s {
-		a = append(a, k)
-	}
-	return a
-}
-
-// IsSuperset returns true if and only if s1 is a superset of s2.
-func (s1 IPNet) IsSuperset(s2 IPNet) bool {
-	for k := range s2 {
-		_, found := s1[k]
-		if !found {
-			return false
-		}
-	}
-	return true
-}
-
-// Equal returns true if and only if s1 is equal (as a set) to s2.
-// Two sets are equal if their membership is identical.
-// (In practice, this means same elements, order doesn't matter)
-func (s1 IPNet) Equal(s2 IPNet) bool {
-	return len(s1) == len(s2) && s1.IsSuperset(s2)
-}
-
-// Len returns the size of the set.
-func (s IPNet) Len() int {
-	return len(s)
-}

1.4/pkg/util/string_flag.go

@@ -1,56 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package util
-
-// StringFlag is a string flag compatible with flags and pflags that keeps track of whether it had a value supplied or not.
-type StringFlag struct {
-	// If Set has been invoked this value is true
-	provided bool
-	// The exact value provided on the flag
-	value string
-}
-
-func NewStringFlag(defaultVal string) StringFlag {
-	return StringFlag{value: defaultVal}
-}
-
-func (f *StringFlag) Default(value string) {
-	f.value = value
-}
-
-func (f StringFlag) String() string {
-	return f.value
-}
-
-func (f StringFlag) Value() string {
-	return f.value
-}
-
-func (f *StringFlag) Set(value string) error {
-	f.value = value
-	f.provided = true
-
-	return nil
-}
-
-func (f StringFlag) Provided() bool {
-	return f.provided
-}
-
-func (f *StringFlag) Type() string {
-	return "string"
-}

1.4/rest/config_test.go

@@ -1,99 +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 rest
-
-import (
-	"strings"
-	"testing"
-
-	"k8s.io/client-go/1.4/pkg/api/testapi"
-)
-
-func TestIsConfigTransportTLS(t *testing.T) {
-	testCases := []struct {
-		Config       *Config
-		TransportTLS bool
-	}{
-		{
-			Config:       &Config{},
-			TransportTLS: false,
-		},
-		{
-			Config: &Config{
-				Host: "https://localhost",
-			},
-			TransportTLS: true,
-		},
-		{
-			Config: &Config{
-				Host: "localhost",
-				TLSClientConfig: TLSClientConfig{
-					CertFile: "foo",
-				},
-			},
-			TransportTLS: true,
-		},
-		{
-			Config: &Config{
-				Host: "///:://localhost",
-				TLSClientConfig: TLSClientConfig{
-					CertFile: "foo",
-				},
-			},
-			TransportTLS: false,
-		},
-		{
-			Config: &Config{
-				Host:     "1.2.3.4:567",
-				Insecure: true,
-			},
-			TransportTLS: true,
-		},
-	}
-	for _, testCase := range testCases {
-		if err := SetKubernetesDefaults(testCase.Config); err != nil {
-			t.Errorf("setting defaults failed for %#v: %v", testCase.Config, err)
-			continue
-		}
-		useTLS := IsConfigTransportTLS(*testCase.Config)
-		if testCase.TransportTLS != useTLS {
-			t.Errorf("expected %v for %#v", testCase.TransportTLS, testCase.Config)
-		}
-	}
-}
-
-func TestSetKubernetesDefaultsUserAgent(t *testing.T) {
-	config := &Config{}
-	if err := SetKubernetesDefaults(config); err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
-	if !strings.Contains(config.UserAgent, "kubernetes/") {
-		t.Errorf("no user agent set: %#v", config)
-	}
-}
-
-func TestRESTClientRequires(t *testing.T) {
-	if _, err := RESTClientFor(&Config{Host: "127.0.0.1", ContentConfig: ContentConfig{NegotiatedSerializer: testapi.Default.NegotiatedSerializer()}}); err == nil {
-		t.Errorf("unexpected non-error")
-	}
-	if _, err := RESTClientFor(&Config{Host: "127.0.0.1", ContentConfig: ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}); err == nil {
-		t.Errorf("unexpected non-error")
-	}
-	if _, err := RESTClientFor(&Config{Host: "127.0.0.1", ContentConfig: ContentConfig{GroupVersion: testapi.Default.GroupVersion(), NegotiatedSerializer: testapi.Default.NegotiatedSerializer()}}); err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
-}

1.4/tools/cache/listers.go

@@ -1,855 +0,0 @@
-/*
-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 cache
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/errors"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/apis/apps"
-	"k8s.io/client-go/1.4/pkg/apis/batch"
-	"k8s.io/client-go/1.4/pkg/apis/certificates"
-	"k8s.io/client-go/1.4/pkg/apis/extensions"
-	"k8s.io/client-go/1.4/pkg/apis/policy"
-	"k8s.io/client-go/1.4/pkg/labels"
-)
-
-//  TODO: generate these classes and methods for all resources of interest using
-// a script.  Can use "go generate" once 1.4 is supported by all users.
-
-// StoreToPodLister makes a Store have the List method of the client.PodInterface
-// The Store must contain (only) Pods.
-//
-// Example:
-// s := cache.NewStore()
-// lw := cache.ListWatch{Client: c, FieldSelector: sel, Resource: "pods"}
-// r := cache.NewReflector(lw, &api.Pod{}, s).Run()
-// l := StoreToPodLister{s}
-// l.List()
-type StoreToPodLister struct {
-	Indexer
-}
-
-// Please note that selector is filtering among the pods that have gotten into
-// the store; there may have been some filtering that already happened before
-// that.
-// We explicitly don't return api.PodList, to avoid expensive allocations, which
-// in most cases are unnecessary.
-func (s *StoreToPodLister) List(selector labels.Selector) (pods []*api.Pod, err error) {
-	for _, m := range s.Indexer.List() {
-		pod := m.(*api.Pod)
-		if selector.Matches(labels.Set(pod.Labels)) {
-			pods = append(pods, pod)
-		}
-	}
-	return pods, nil
-}
-
-// Pods is taking baby steps to be more like the api in pkg/client
-func (s *StoreToPodLister) Pods(namespace string) storePodsNamespacer {
-	return storePodsNamespacer{s.Indexer, namespace}
-}
-
-type storePodsNamespacer struct {
-	indexer   Indexer
-	namespace string
-}
-
-// Please note that selector is filtering among the pods that have gotten into
-// the store; there may have been some filtering that already happened before
-// that.
-// We explicitly don't return api.PodList, to avoid expensive allocations, which
-// in most cases are unnecessary.
-func (s storePodsNamespacer) List(selector labels.Selector) (pods []*api.Pod, err error) {
-	if s.namespace == api.NamespaceAll {
-		for _, m := range s.indexer.List() {
-			pod := m.(*api.Pod)
-			if selector.Matches(labels.Set(pod.Labels)) {
-				pods = append(pods, pod)
-			}
-		}
-		return pods, nil
-	}
-
-	key := &api.Pod{ObjectMeta: api.ObjectMeta{Namespace: s.namespace}}
-	items, err := s.indexer.Index(NamespaceIndex, key)
-	if err != nil {
-		// Ignore error; do slow search without index.
-		glog.Warningf("can not retrieve list of objects using index : %v", err)
-		for _, m := range s.indexer.List() {
-			pod := m.(*api.Pod)
-			if s.namespace == pod.Namespace && selector.Matches(labels.Set(pod.Labels)) {
-				pods = append(pods, pod)
-			}
-		}
-		return pods, nil
-	}
-	for _, m := range items {
-		pod := m.(*api.Pod)
-		if selector.Matches(labels.Set(pod.Labels)) {
-			pods = append(pods, pod)
-		}
-	}
-	return pods, nil
-}
-
-func (s storePodsNamespacer) Get(name string) (*api.Pod, error) {
-	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(api.Resource("pod"), name)
-	}
-	return obj.(*api.Pod), nil
-}
-
-// Exists returns true if a pod matching the namespace/name of the given pod exists in the store.
-func (s *StoreToPodLister) Exists(pod *api.Pod) (bool, error) {
-	_, exists, err := s.Indexer.Get(pod)
-	if err != nil {
-		return false, err
-	}
-	return exists, nil
-}
-
-// NodeConditionPredicate is a function that indicates whether the given node's conditions meet
-// some set of criteria defined by the function.
-type NodeConditionPredicate func(node *api.Node) bool
-
-// StoreToNodeLister makes a Store have the List method of the client.NodeInterface
-// The Store must contain (only) Nodes.
-type StoreToNodeLister struct {
-	Store
-}
-
-func (s *StoreToNodeLister) List() (machines api.NodeList, err error) {
-	for _, m := range s.Store.List() {
-		machines.Items = append(machines.Items, *(m.(*api.Node)))
-	}
-	return machines, nil
-}
-
-// NodeCondition returns a storeToNodeConditionLister
-func (s *StoreToNodeLister) NodeCondition(predicate NodeConditionPredicate) storeToNodeConditionLister {
-	// TODO: Move this filtering server side. Currently our selectors don't facilitate searching through a list so we
-	// have the reflector filter out the Unschedulable field and sift through node conditions in the lister.
-	return storeToNodeConditionLister{s.Store, predicate}
-}
-
-// storeToNodeConditionLister filters and returns nodes matching the given type and status from the store.
-type storeToNodeConditionLister struct {
-	store     Store
-	predicate NodeConditionPredicate
-}
-
-// List returns a list of nodes that match the conditions defined by the predicate functions in the storeToNodeConditionLister.
-func (s storeToNodeConditionLister) List() (nodes []*api.Node, err error) {
-	for _, m := range s.store.List() {
-		node := m.(*api.Node)
-		if s.predicate(node) {
-			nodes = append(nodes, node)
-		} else {
-			glog.V(5).Infof("Node %s matches none of the conditions", node.Name)
-		}
-	}
-	return
-}
-
-// StoreToReplicationControllerLister gives a store List and Exists methods. The store must contain only ReplicationControllers.
-type StoreToReplicationControllerLister struct {
-	Indexer
-}
-
-// Exists checks if the given rc exists in the store.
-func (s *StoreToReplicationControllerLister) Exists(controller *api.ReplicationController) (bool, error) {
-	_, exists, err := s.Indexer.Get(controller)
-	if err != nil {
-		return false, err
-	}
-	return exists, nil
-}
-
-// StoreToReplicationControllerLister lists all controllers in the store.
-// TODO: converge on the interface in pkg/client
-func (s *StoreToReplicationControllerLister) List() (controllers []api.ReplicationController, err error) {
-	for _, c := range s.Indexer.List() {
-		controllers = append(controllers, *(c.(*api.ReplicationController)))
-	}
-	return controllers, nil
-}
-
-func (s *StoreToReplicationControllerLister) ReplicationControllers(namespace string) storeReplicationControllersNamespacer {
-	return storeReplicationControllersNamespacer{s.Indexer, namespace}
-}
-
-type storeReplicationControllersNamespacer struct {
-	indexer   Indexer
-	namespace string
-}
-
-func (s storeReplicationControllersNamespacer) List(selector labels.Selector) ([]api.ReplicationController, error) {
-	controllers := []api.ReplicationController{}
-
-	if s.namespace == api.NamespaceAll {
-		for _, m := range s.indexer.List() {
-			rc := *(m.(*api.ReplicationController))
-			if selector.Matches(labels.Set(rc.Labels)) {
-				controllers = append(controllers, rc)
-			}
-		}
-		return controllers, nil
-	}
-
-	key := &api.ReplicationController{ObjectMeta: api.ObjectMeta{Namespace: s.namespace}}
-	items, err := s.indexer.Index(NamespaceIndex, key)
-	if err != nil {
-		// Ignore error; do slow search without index.
-		glog.Warningf("can not retrieve list of objects using index : %v", err)
-		for _, m := range s.indexer.List() {
-			rc := *(m.(*api.ReplicationController))
-			if s.namespace == rc.Namespace && selector.Matches(labels.Set(rc.Labels)) {
-				controllers = append(controllers, rc)
-			}
-		}
-		return controllers, nil
-	}
-	for _, m := range items {
-		rc := *(m.(*api.ReplicationController))
-		if selector.Matches(labels.Set(rc.Labels)) {
-			controllers = append(controllers, rc)
-		}
-	}
-	return controllers, nil
-}
-
-func (s storeReplicationControllersNamespacer) Get(name string) (*api.ReplicationController, error) {
-	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(api.Resource("replicationcontroller"), name)
-	}
-	return obj.(*api.ReplicationController), nil
-}
-
-// GetPodControllers returns a list of replication controllers managing a pod. Returns an error only if no matching controllers are found.
-func (s *StoreToReplicationControllerLister) GetPodControllers(pod *api.Pod) (controllers []api.ReplicationController, err error) {
-	var selector labels.Selector
-	var rc api.ReplicationController
-
-	if len(pod.Labels) == 0 {
-		err = fmt.Errorf("no controllers found for pod %v because it has no labels", pod.Name)
-		return
-	}
-
-	key := &api.ReplicationController{ObjectMeta: api.ObjectMeta{Namespace: pod.Namespace}}
-	items, err := s.Indexer.Index(NamespaceIndex, key)
-	if err != nil {
-		return
-	}
-
-	for _, m := range items {
-		rc = *m.(*api.ReplicationController)
-		selector = labels.Set(rc.Spec.Selector).AsSelectorPreValidated()
-
-		// If an rc with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
-			continue
-		}
-		controllers = append(controllers, rc)
-	}
-	if len(controllers) == 0 {
-		err = fmt.Errorf("could not find controller for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-	return
-}
-
-// StoreToDeploymentLister gives a store List and Exists methods. The store must contain only Deployments.
-type StoreToDeploymentLister struct {
-	Indexer
-}
-
-// Exists checks if the given deployment exists in the store.
-func (s *StoreToDeploymentLister) Exists(deployment *extensions.Deployment) (bool, error) {
-	_, exists, err := s.Indexer.Get(deployment)
-	if err != nil {
-		return false, err
-	}
-	return exists, nil
-}
-
-// StoreToDeploymentLister lists all deployments in the store.
-// TODO: converge on the interface in pkg/client
-func (s *StoreToDeploymentLister) List() (deployments []extensions.Deployment, err error) {
-	for _, c := range s.Indexer.List() {
-		deployments = append(deployments, *(c.(*extensions.Deployment)))
-	}
-	return deployments, nil
-}
-
-// GetDeploymentsForReplicaSet returns a list of deployments managing a replica set. Returns an error only if no matching deployments are found.
-func (s *StoreToDeploymentLister) GetDeploymentsForReplicaSet(rs *extensions.ReplicaSet) (deployments []extensions.Deployment, err error) {
-	if len(rs.Labels) == 0 {
-		err = fmt.Errorf("no deployments found for ReplicaSet %v because it has no labels", rs.Name)
-		return
-	}
-
-	// TODO: MODIFY THIS METHOD so that it checks for the podTemplateSpecHash label
-	dList, err := s.Deployments(rs.Namespace).List(labels.Everything())
-	if err != nil {
-		return
-	}
-	for _, d := range dList {
-		selector, err := unversioned.LabelSelectorAsSelector(d.Spec.Selector)
-		if err != nil {
-			return nil, fmt.Errorf("invalid label selector: %v", err)
-		}
-		// If a deployment with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(rs.Labels)) {
-			continue
-		}
-		deployments = append(deployments, d)
-	}
-	if len(deployments) == 0 {
-		err = fmt.Errorf("could not find deployments set for ReplicaSet %s in namespace %s with labels: %v", rs.Name, rs.Namespace, rs.Labels)
-	}
-	return
-}
-
-type storeToDeploymentNamespacer struct {
-	indexer   Indexer
-	namespace string
-}
-
-// storeToDeploymentNamespacer lists deployments under its namespace in the store.
-func (s storeToDeploymentNamespacer) List(selector labels.Selector) (deployments []extensions.Deployment, err error) {
-	if s.namespace == api.NamespaceAll {
-		for _, m := range s.indexer.List() {
-			d := *(m.(*extensions.Deployment))
-			if selector.Matches(labels.Set(d.Labels)) {
-				deployments = append(deployments, d)
-			}
-		}
-		return
-	}
-
-	key := &extensions.Deployment{ObjectMeta: api.ObjectMeta{Namespace: s.namespace}}
-	items, err := s.indexer.Index(NamespaceIndex, key)
-	if err != nil {
-		// Ignore error; do slow search without index.
-		glog.Warningf("can not retrieve list of objects using index : %v", err)
-		for _, m := range s.indexer.List() {
-			d := *(m.(*extensions.Deployment))
-			if s.namespace == d.Namespace && selector.Matches(labels.Set(d.Labels)) {
-				deployments = append(deployments, d)
-			}
-		}
-		return deployments, nil
-	}
-	for _, m := range items {
-		d := *(m.(*extensions.Deployment))
-		if selector.Matches(labels.Set(d.Labels)) {
-			deployments = append(deployments, d)
-		}
-	}
-	return
-}
-
-func (s *StoreToDeploymentLister) Deployments(namespace string) storeToDeploymentNamespacer {
-	return storeToDeploymentNamespacer{s.Indexer, namespace}
-}
-
-// GetDeploymentsForPods returns a list of deployments managing a pod. Returns an error only if no matching deployments are found.
-func (s *StoreToDeploymentLister) GetDeploymentsForPod(pod *api.Pod) (deployments []extensions.Deployment, err error) {
-	if len(pod.Labels) == 0 {
-		err = fmt.Errorf("no deployments found for Pod %v because it has no labels", pod.Name)
-		return
-	}
-
-	if len(pod.Labels[extensions.DefaultDeploymentUniqueLabelKey]) == 0 {
-		return
-	}
-
-	dList, err := s.Deployments(pod.Namespace).List(labels.Everything())
-	if err != nil {
-		return
-	}
-	for _, d := range dList {
-		selector, err := unversioned.LabelSelectorAsSelector(d.Spec.Selector)
-		if err != nil {
-			return nil, fmt.Errorf("invalid label selector: %v", err)
-		}
-		// If a deployment with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
-			continue
-		}
-		deployments = append(deployments, d)
-	}
-	if len(deployments) == 0 {
-		err = fmt.Errorf("could not find deployments set for Pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-	return
-}
-
-// StoreToReplicaSetLister gives a store List and Exists methods. The store must contain only ReplicaSets.
-type StoreToReplicaSetLister struct {
-	Store
-}
-
-// Exists checks if the given ReplicaSet exists in the store.
-func (s *StoreToReplicaSetLister) Exists(rs *extensions.ReplicaSet) (bool, error) {
-	_, exists, err := s.Store.Get(rs)
-	if err != nil {
-		return false, err
-	}
-	return exists, nil
-}
-
-// List lists all ReplicaSets in the store.
-// TODO: converge on the interface in pkg/client
-func (s *StoreToReplicaSetLister) List() (rss []extensions.ReplicaSet, err error) {
-	for _, rs := range s.Store.List() {
-		rss = append(rss, *(rs.(*extensions.ReplicaSet)))
-	}
-	return rss, nil
-}
-
-type storeReplicaSetsNamespacer struct {
-	store     Store
-	namespace string
-}
-
-func (s storeReplicaSetsNamespacer) List(selector labels.Selector) (rss []extensions.ReplicaSet, err error) {
-	for _, c := range s.store.List() {
-		rs := *(c.(*extensions.ReplicaSet))
-		if s.namespace == api.NamespaceAll || s.namespace == rs.Namespace {
-			if selector.Matches(labels.Set(rs.Labels)) {
-				rss = append(rss, rs)
-			}
-		}
-	}
-	return
-}
-
-func (s storeReplicaSetsNamespacer) Get(name string) (*extensions.ReplicaSet, error) {
-	obj, exists, err := s.store.GetByKey(s.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(extensions.Resource("replicaset"), name)
-	}
-	return obj.(*extensions.ReplicaSet), nil
-}
-
-func (s *StoreToReplicaSetLister) ReplicaSets(namespace string) storeReplicaSetsNamespacer {
-	return storeReplicaSetsNamespacer{s.Store, namespace}
-}
-
-// GetPodReplicaSets returns a list of ReplicaSets managing a pod. Returns an error only if no matching ReplicaSets are found.
-func (s *StoreToReplicaSetLister) GetPodReplicaSets(pod *api.Pod) (rss []extensions.ReplicaSet, err error) {
-	var selector labels.Selector
-	var rs extensions.ReplicaSet
-
-	if len(pod.Labels) == 0 {
-		err = fmt.Errorf("no ReplicaSets found for pod %v because it has no labels", pod.Name)
-		return
-	}
-
-	for _, m := range s.Store.List() {
-		rs = *m.(*extensions.ReplicaSet)
-		if rs.Namespace != pod.Namespace {
-			continue
-		}
-		selector, err = unversioned.LabelSelectorAsSelector(rs.Spec.Selector)
-		if err != nil {
-			err = fmt.Errorf("invalid selector: %v", err)
-			return
-		}
-
-		// If a ReplicaSet with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
-			continue
-		}
-		rss = append(rss, rs)
-	}
-	if len(rss) == 0 {
-		err = fmt.Errorf("could not find ReplicaSet for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-	return
-}
-
-// StoreToDaemonSetLister gives a store List and Exists methods. The store must contain only DaemonSets.
-type StoreToDaemonSetLister struct {
-	Store
-}
-
-// Exists checks if the given daemon set exists in the store.
-func (s *StoreToDaemonSetLister) Exists(ds *extensions.DaemonSet) (bool, error) {
-	_, exists, err := s.Store.Get(ds)
-	if err != nil {
-		return false, err
-	}
-	return exists, nil
-}
-
-// List lists all daemon sets in the store.
-// TODO: converge on the interface in pkg/client
-func (s *StoreToDaemonSetLister) List() (dss extensions.DaemonSetList, err error) {
-	for _, c := range s.Store.List() {
-		dss.Items = append(dss.Items, *(c.(*extensions.DaemonSet)))
-	}
-	return dss, nil
-}
-
-// GetPodDaemonSets returns a list of daemon sets managing a pod.
-// Returns an error if and only if no matching daemon sets are found.
-func (s *StoreToDaemonSetLister) GetPodDaemonSets(pod *api.Pod) (daemonSets []extensions.DaemonSet, err error) {
-	var selector labels.Selector
-	var daemonSet extensions.DaemonSet
-
-	if len(pod.Labels) == 0 {
-		err = fmt.Errorf("no daemon sets found for pod %v because it has no labels", pod.Name)
-		return
-	}
-
-	for _, m := range s.Store.List() {
-		daemonSet = *m.(*extensions.DaemonSet)
-		if daemonSet.Namespace != pod.Namespace {
-			continue
-		}
-		selector, err = unversioned.LabelSelectorAsSelector(daemonSet.Spec.Selector)
-		if err != nil {
-			// this should not happen if the DaemonSet passed validation
-			return nil, err
-		}
-
-		// If a daemonSet with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
-			continue
-		}
-		daemonSets = append(daemonSets, daemonSet)
-	}
-	if len(daemonSets) == 0 {
-		err = fmt.Errorf("could not find daemon set for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-	return
-}
-
-// StoreToServiceLister makes a Store that has the List method of the client.ServiceInterface
-// The Store must contain (only) Services.
-type StoreToServiceLister struct {
-	Store
-}
-
-func (s *StoreToServiceLister) List() (services api.ServiceList, err error) {
-	for _, m := range s.Store.List() {
-		services.Items = append(services.Items, *(m.(*api.Service)))
-	}
-	return services, nil
-}
-
-// TODO: Move this back to scheduler as a helper function that takes a Store,
-// rather than a method of StoreToServiceLister.
-func (s *StoreToServiceLister) GetPodServices(pod *api.Pod) (services []api.Service, err error) {
-	var selector labels.Selector
-	var service api.Service
-
-	for _, m := range s.Store.List() {
-		service = *m.(*api.Service)
-		// consider only services that are in the same namespace as the pod
-		if service.Namespace != pod.Namespace {
-			continue
-		}
-		if service.Spec.Selector == nil {
-			// services with nil selectors match nothing, not everything.
-			continue
-		}
-		selector = labels.Set(service.Spec.Selector).AsSelectorPreValidated()
-		if selector.Matches(labels.Set(pod.Labels)) {
-			services = append(services, service)
-		}
-	}
-	if len(services) == 0 {
-		err = fmt.Errorf("could not find service for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-
-	return
-}
-
-// StoreToEndpointsLister makes a Store that lists endpoints.
-type StoreToEndpointsLister struct {
-	Store
-}
-
-// List lists all endpoints in the store.
-func (s *StoreToEndpointsLister) List() (services api.EndpointsList, err error) {
-	for _, m := range s.Store.List() {
-		services.Items = append(services.Items, *(m.(*api.Endpoints)))
-	}
-	return services, nil
-}
-
-// GetServiceEndpoints returns the endpoints of a service, matched on service name.
-func (s *StoreToEndpointsLister) GetServiceEndpoints(svc *api.Service) (ep api.Endpoints, err error) {
-	for _, m := range s.Store.List() {
-		ep = *m.(*api.Endpoints)
-		if svc.Name == ep.Name && svc.Namespace == ep.Namespace {
-			return ep, nil
-		}
-	}
-	err = fmt.Errorf("could not find endpoints for service: %v", svc.Name)
-	return
-}
-
-// StoreToJobLister gives a store List and Exists methods. The store must contain only Jobs.
-type StoreToJobLister struct {
-	Store
-}
-
-// Exists checks if the given job exists in the store.
-func (s *StoreToJobLister) Exists(job *batch.Job) (bool, error) {
-	_, exists, err := s.Store.Get(job)
-	if err != nil {
-		return false, err
-	}
-	return exists, nil
-}
-
-// StoreToJobLister lists all jobs in the store.
-func (s *StoreToJobLister) List() (jobs batch.JobList, err error) {
-	for _, c := range s.Store.List() {
-		jobs.Items = append(jobs.Items, *(c.(*batch.Job)))
-	}
-	return jobs, nil
-}
-
-// GetPodJobs returns a list of jobs managing a pod. Returns an error only if no matching jobs are found.
-func (s *StoreToJobLister) GetPodJobs(pod *api.Pod) (jobs []batch.Job, err error) {
-	var selector labels.Selector
-	var job batch.Job
-
-	if len(pod.Labels) == 0 {
-		err = fmt.Errorf("no jobs found for pod %v because it has no labels", pod.Name)
-		return
-	}
-
-	for _, m := range s.Store.List() {
-		job = *m.(*batch.Job)
-		if job.Namespace != pod.Namespace {
-			continue
-		}
-
-		selector, _ = unversioned.LabelSelectorAsSelector(job.Spec.Selector)
-		if !selector.Matches(labels.Set(pod.Labels)) {
-			continue
-		}
-		jobs = append(jobs, job)
-	}
-	if len(jobs) == 0 {
-		err = fmt.Errorf("could not find jobs for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-	return
-}
-
-// Typed wrapper around a store of PersistentVolumes
-type StoreToPVFetcher struct {
-	Store
-}
-
-// GetPersistentVolumeInfo returns cached data for the PersistentVolume 'id'.
-func (s *StoreToPVFetcher) GetPersistentVolumeInfo(id string) (*api.PersistentVolume, error) {
-	o, exists, err := s.Get(&api.PersistentVolume{ObjectMeta: api.ObjectMeta{Name: id}})
-
-	if err != nil {
-		return nil, fmt.Errorf("error retrieving PersistentVolume '%v' from cache: %v", id, err)
-	}
-
-	if !exists {
-		return nil, fmt.Errorf("PersistentVolume '%v' not found", id)
-	}
-
-	return o.(*api.PersistentVolume), nil
-}
-
-// Typed wrapper around a store of PersistentVolumeClaims
-type StoreToPVCFetcher struct {
-	Store
-}
-
-// GetPersistentVolumeClaimInfo returns cached data for the PersistentVolumeClaim 'id'.
-func (s *StoreToPVCFetcher) GetPersistentVolumeClaimInfo(namespace string, id string) (*api.PersistentVolumeClaim, error) {
-	o, exists, err := s.Get(&api.PersistentVolumeClaim{ObjectMeta: api.ObjectMeta{Namespace: namespace, Name: id}})
-	if err != nil {
-		return nil, fmt.Errorf("error retrieving PersistentVolumeClaim '%s/%s' from cache: %v", namespace, id, err)
-	}
-
-	if !exists {
-		return nil, fmt.Errorf("PersistentVolumeClaim '%s/%s' not found", namespace, id)
-	}
-
-	return o.(*api.PersistentVolumeClaim), nil
-}
-
-// StoreToPetSetLister gives a store List and Exists methods. The store must contain only PetSets.
-type StoreToPetSetLister struct {
-	Store
-}
-
-// Exists checks if the given PetSet exists in the store.
-func (s *StoreToPetSetLister) Exists(ps *apps.PetSet) (bool, error) {
-	_, exists, err := s.Store.Get(ps)
-	if err != nil {
-		return false, err
-	}
-	return exists, nil
-}
-
-// List lists all PetSets in the store.
-func (s *StoreToPetSetLister) List() (psList []apps.PetSet, err error) {
-	for _, ps := range s.Store.List() {
-		psList = append(psList, *(ps.(*apps.PetSet)))
-	}
-	return psList, nil
-}
-
-type storePetSetsNamespacer struct {
-	store     Store
-	namespace string
-}
-
-func (s *StoreToPetSetLister) PetSets(namespace string) storePetSetsNamespacer {
-	return storePetSetsNamespacer{s.Store, namespace}
-}
-
-// GetPodPetSets returns a list of PetSets managing a pod. Returns an error only if no matching PetSets are found.
-func (s *StoreToPetSetLister) GetPodPetSets(pod *api.Pod) (psList []apps.PetSet, err error) {
-	var selector labels.Selector
-	var ps apps.PetSet
-
-	if len(pod.Labels) == 0 {
-		err = fmt.Errorf("no PetSets found for pod %v because it has no labels", pod.Name)
-		return
-	}
-
-	for _, m := range s.Store.List() {
-		ps = *m.(*apps.PetSet)
-		if ps.Namespace != pod.Namespace {
-			continue
-		}
-		selector, err = unversioned.LabelSelectorAsSelector(ps.Spec.Selector)
-		if err != nil {
-			err = fmt.Errorf("invalid selector: %v", err)
-			return
-		}
-
-		// If a PetSet with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
-			continue
-		}
-		psList = append(psList, ps)
-	}
-	if len(psList) == 0 {
-		err = fmt.Errorf("could not find PetSet for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-	return
-}
-
-// StoreToCertificateRequestLister gives a store List and Exists methods. The store must contain only CertificateRequests.
-type StoreToCertificateRequestLister struct {
-	Store
-}
-
-// Exists checks if the given csr exists in the store.
-func (s *StoreToCertificateRequestLister) Exists(csr *certificates.CertificateSigningRequest) (bool, error) {
-	_, exists, err := s.Store.Get(csr)
-	if err != nil {
-		return false, err
-	}
-	return exists, nil
-}
-
-// StoreToCertificateRequestLister lists all csrs in the store.
-func (s *StoreToCertificateRequestLister) List() (csrs certificates.CertificateSigningRequestList, err error) {
-	for _, c := range s.Store.List() {
-		csrs.Items = append(csrs.Items, *(c.(*certificates.CertificateSigningRequest)))
-	}
-	return csrs, nil
-}
-
-// IndexerToNamespaceLister gives an Indexer List method
-type IndexerToNamespaceLister struct {
-	Indexer
-}
-
-// List returns a list of namespaces
-func (i *IndexerToNamespaceLister) List(selector labels.Selector) (namespaces []*api.Namespace, err error) {
-	for _, m := range i.Indexer.List() {
-		namespace := m.(*api.Namespace)
-		if selector.Matches(labels.Set(namespace.Labels)) {
-			namespaces = append(namespaces, namespace)
-		}
-	}
-
-	return namespaces, nil
-}
-
-type StoreToPodDisruptionBudgetLister struct {
-	Store
-}
-
-// GetPodPodDisruptionBudgets returns a list of PodDisruptionBudgets matching a pod.  Returns an error only if no matching PodDisruptionBudgets are found.
-func (s *StoreToPodDisruptionBudgetLister) GetPodPodDisruptionBudgets(pod *api.Pod) (pdbList []policy.PodDisruptionBudget, err error) {
-	var selector labels.Selector
-
-	if len(pod.Labels) == 0 {
-		err = fmt.Errorf("no PodDisruptionBudgets found for pod %v because it has no labels", pod.Name)
-		return
-	}
-
-	for _, m := range s.Store.List() {
-		pdb, ok := m.(*policy.PodDisruptionBudget)
-		if !ok {
-			glog.Errorf("Unexpected: %v is not a PodDisruptionBudget", m)
-			continue
-		}
-		if pdb.Namespace != pod.Namespace {
-			continue
-		}
-		selector, err = unversioned.LabelSelectorAsSelector(pdb.Spec.Selector)
-		if err != nil {
-			glog.Warningf("invalid selector: %v", err)
-			// TODO(mml): add an event to the PDB
-			continue
-		}
-
-		// If a PDB with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
-			continue
-		}
-		pdbList = append(pdbList, *pdb)
-	}
-	if len(pdbList) == 0 {
-		err = fmt.Errorf("could not find PodDisruptionBudget for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-	return
-}

1.4/vendor/github.com/emicklei/go-restful/bench_test.sh

@@ -1,10 +0,0 @@
-#go test -run=none -file bench_test.go -test.bench . -cpuprofile=bench_test.out
-
-go test -c
-./go-restful.test -test.run=none -test.cpuprofile=tmp.prof -test.bench=BenchmarkMany
-./go-restful.test -test.run=none -test.cpuprofile=curly.prof -test.bench=BenchmarkManyCurly
-
-#go tool pprof go-restful.test tmp.prof
-go tool pprof go-restful.test curly.prof
-
-

1.4/vendor/github.com/emicklei/go-restful/coverage.sh

@@ -1,2 +0,0 @@
-go test -coverprofile=coverage.out
-go tool cover -html=coverage.out

1.4/vendor/github.com/emicklei/go-restful/install.sh

@@ -1,10 +0,0 @@
-go test -test.v ...restful && \
-go test -test.v ...swagger && \
-go vet ...restful && \
-go fmt ...swagger && \
-go install ...swagger && \
-go fmt ...restful && \
-go install ...restful
-cd examples
-	ls *.go | xargs -I {} go build -o /tmp/ignore {}
-	cd ..

1.4/vendor/github.com/ghodss/yaml/.travis.yml

@@ -1,7 +0,0 @@
-language: go
-go:
-  - 1.3
-  - 1.4
-script:
-  - go test
-  - go build

1.4/vendor/github.com/google/gofuzz/.travis.yml

@@ -1,13 +0,0 @@
-language: go
-
-go:
-  - 1.4
-  - 1.3
-  - 1.2
-  - tip
-
-install:
-  - if ! go get code.google.com/p/go.tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi
-
-script:
-  - go test -cover

1.4/vendor/github.com/imdario/mergo/.travis.yml

@@ -1,2 +0,0 @@
-language: go
-install: go get -t

1.4/vendor/github.com/juju/ratelimit/LICENSE

@@ -1,191 +0,0 @@
-All files in this repository are licensed as follows. If you contribute
-to this repository, it is assumed that you license your contribution
-under the same license unless you state otherwise.
-
-All files Copyright (C) 2015 Canonical Ltd. unless otherwise specified in the file.
-
-This software is licensed under the LGPLv3, included below.
-
-As a special exception to the GNU Lesser General Public License version 3
-("LGPL3"), the copyright holders of this Library give you permission to
-convey to a third party a Combined Work that links statically or dynamically
-to this Library without providing any Minimal Corresponding Source or
-Minimal Application Code as set out in 4d or providing the installation
-information set out in section 4e, provided that you comply with the other
-provisions of LGPL3 and provided that you meet, for the Application the
-terms and conditions of the license(s) which apply to the Application.
-
-Except as stated in this special exception, the provisions of LGPL3 will
-continue to comply in full to this Library. If you modify this Library, you
-may apply this exception to your version of this Library, but you are not
-obliged to do so. If you do not wish to do so, delete this exception
-statement from your version. This exception does not (and cannot) modify any
-license terms which apply to the Application, with which you must still
-comply.
-
-
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

1.4/vendor/github.com/juju/ratelimit/ratelimit.go

@@ -1,245 +0,0 @@
-// Copyright 2014 Canonical Ltd.
-// Licensed under the LGPLv3 with static-linking exception.
-// See LICENCE file for details.
-
-// The ratelimit package provides an efficient token bucket implementation
-// that can be used to limit the rate of arbitrary things.
-// See http://en.wikipedia.org/wiki/Token_bucket.
-package ratelimit
-
-import (
-	"math"
-	"strconv"
-	"sync"
-	"time"
-)
-
-// Bucket represents a token bucket that fills at a predetermined rate.
-// Methods on Bucket may be called concurrently.
-type Bucket struct {
-	startTime    time.Time
-	capacity     int64
-	quantum      int64
-	fillInterval time.Duration
-
-	// The mutex guards the fields following it.
-	mu sync.Mutex
-
-	// avail holds the number of available tokens
-	// in the bucket, as of availTick ticks from startTime.
-	// It will be negative when there are consumers
-	// waiting for tokens.
-	avail     int64
-	availTick int64
-}
-
-// NewBucket returns a new token bucket that fills at the
-// rate of one token every fillInterval, up to the given
-// maximum capacity. Both arguments must be
-// positive. The bucket is initially full.
-func NewBucket(fillInterval time.Duration, capacity int64) *Bucket {
-	return NewBucketWithQuantum(fillInterval, capacity, 1)
-}
-
-// rateMargin specifes the allowed variance of actual
-// rate from specified rate. 1% seems reasonable.
-const rateMargin = 0.01
-
-// NewBucketWithRate returns a token bucket that fills the bucket
-// at the rate of rate tokens per second up to the given
-// maximum capacity. Because of limited clock resolution,
-// at high rates, the actual rate may be up to 1% different from the
-// specified rate.
-func NewBucketWithRate(rate float64, capacity int64) *Bucket {
-	for quantum := int64(1); quantum < 1<<50; quantum = nextQuantum(quantum) {
-		fillInterval := time.Duration(1e9 * float64(quantum) / rate)
-		if fillInterval <= 0 {
-			continue
-		}
-		tb := NewBucketWithQuantum(fillInterval, capacity, quantum)
-		if diff := math.Abs(tb.Rate() - rate); diff/rate <= rateMargin {
-			return tb
-		}
-	}
-	panic("cannot find suitable quantum for " + strconv.FormatFloat(rate, 'g', -1, 64))
-}
-
-// nextQuantum returns the next quantum to try after q.
-// We grow the quantum exponentially, but slowly, so we
-// get a good fit in the lower numbers.
-func nextQuantum(q int64) int64 {
-	q1 := q * 11 / 10
-	if q1 == q {
-		q1++
-	}
-	return q1
-}
-
-// NewBucketWithQuantum is similar to NewBucket, but allows
-// the specification of the quantum size - quantum tokens
-// are added every fillInterval.
-func NewBucketWithQuantum(fillInterval time.Duration, capacity, quantum int64) *Bucket {
-	if fillInterval <= 0 {
-		panic("token bucket fill interval is not > 0")
-	}
-	if capacity <= 0 {
-		panic("token bucket capacity is not > 0")
-	}
-	if quantum <= 0 {
-		panic("token bucket quantum is not > 0")
-	}
-	return &Bucket{
-		startTime:    time.Now(),
-		capacity:     capacity,
-		quantum:      quantum,
-		avail:        capacity,
-		fillInterval: fillInterval,
-	}
-}
-
-// Wait takes count tokens from the bucket, waiting until they are
-// available.
-func (tb *Bucket) Wait(count int64) {
-	if d := tb.Take(count); d > 0 {
-		time.Sleep(d)
-	}
-}
-
-// WaitMaxDuration is like Wait except that it will
-// only take tokens from the bucket if it needs to wait
-// for no greater than maxWait. It reports whether
-// any tokens have been removed from the bucket
-// If no tokens have been removed, it returns immediately.
-func (tb *Bucket) WaitMaxDuration(count int64, maxWait time.Duration) bool {
-	d, ok := tb.TakeMaxDuration(count, maxWait)
-	if d > 0 {
-		time.Sleep(d)
-	}
-	return ok
-}
-
-const infinityDuration time.Duration = 0x7fffffffffffffff
-
-// Take takes count tokens from the bucket without blocking. It returns
-// the time that the caller should wait until the tokens are actually
-// available.
-//
-// Note that if the request is irrevocable - there is no way to return
-// tokens to the bucket once this method commits us to taking them.
-func (tb *Bucket) Take(count int64) time.Duration {
-	d, _ := tb.take(time.Now(), count, infinityDuration)
-	return d
-}
-
-// TakeMaxDuration is like Take, except that
-// it will only take tokens from the bucket if the wait
-// time for the tokens is no greater than maxWait.
-//
-// If it would take longer than maxWait for the tokens
-// to become available, it does nothing and reports false,
-// otherwise it returns the time that the caller should
-// wait until the tokens are actually available, and reports
-// true.
-func (tb *Bucket) TakeMaxDuration(count int64, maxWait time.Duration) (time.Duration, bool) {
-	return tb.take(time.Now(), count, maxWait)
-}
-
-// TakeAvailable takes up to count immediately available tokens from the
-// bucket. It returns the number of tokens removed, or zero if there are
-// no available tokens. It does not block.
-func (tb *Bucket) TakeAvailable(count int64) int64 {
-	return tb.takeAvailable(time.Now(), count)
-}
-
-// takeAvailable is the internal version of TakeAvailable - it takes the
-// current time as an argument to enable easy testing.
-func (tb *Bucket) takeAvailable(now time.Time, count int64) int64 {
-	if count <= 0 {
-		return 0
-	}
-	tb.mu.Lock()
-	defer tb.mu.Unlock()
-
-	tb.adjust(now)
-	if tb.avail <= 0 {
-		return 0
-	}
-	if count > tb.avail {
-		count = tb.avail
-	}
-	tb.avail -= count
-	return count
-}
-
-// Available returns the number of available tokens. It will be negative
-// when there are consumers waiting for tokens. Note that if this
-// returns greater than zero, it does not guarantee that calls that take
-// tokens from the buffer will succeed, as the number of available
-// tokens could have changed in the meantime. This method is intended
-// primarily for metrics reporting and debugging.
-func (tb *Bucket) Available() int64 {
-	return tb.available(time.Now())
-}
-
-// available is the internal version of available - it takes the current time as
-// an argument to enable easy testing.
-func (tb *Bucket) available(now time.Time) int64 {
-	tb.mu.Lock()
-	defer tb.mu.Unlock()
-	tb.adjust(now)
-	return tb.avail
-}
-
-// Capacity returns the capacity that the bucket was created with.
-func (tb *Bucket) Capacity() int64 {
-	return tb.capacity
-}
-
-// Rate returns the fill rate of the bucket, in tokens per second.
-func (tb *Bucket) Rate() float64 {
-	return 1e9 * float64(tb.quantum) / float64(tb.fillInterval)
-}
-
-// take is the internal version of Take - it takes the current time as
-// an argument to enable easy testing.
-func (tb *Bucket) take(now time.Time, count int64, maxWait time.Duration) (time.Duration, bool) {
-	if count <= 0 {
-		return 0, true
-	}
-	tb.mu.Lock()
-	defer tb.mu.Unlock()
-
-	currentTick := tb.adjust(now)
-	avail := tb.avail - count
-	if avail >= 0 {
-		tb.avail = avail
-		return 0, true
-	}
-	// Round up the missing tokens to the nearest multiple
-	// of quantum - the tokens won't be available until
-	// that tick.
-	endTick := currentTick + (-avail+tb.quantum-1)/tb.quantum
-	endTime := tb.startTime.Add(time.Duration(endTick) * tb.fillInterval)
-	waitTime := endTime.Sub(now)
-	if waitTime > maxWait {
-		return 0, false
-	}
-	tb.avail = avail
-	return waitTime, true
-}
-
-// adjust adjusts the current bucket capacity based on the current time.
-// It returns the current tick.
-func (tb *Bucket) adjust(now time.Time) (currentTick int64) {
-	currentTick = int64(now.Sub(tb.startTime) / tb.fillInterval)
-
-	if tb.avail >= tb.capacity {
-		return
-	}
-	tb.avail += (currentTick - tb.availTick) * tb.quantum
-	if tb.avail > tb.capacity {
-		tb.avail = tb.capacity
-	}
-	tb.availTick = currentTick
-	return
-}

1.4/vendor/github.com/juju/ratelimit/reader.go

@@ -1,51 +0,0 @@
-// Copyright 2014 Canonical Ltd.
-// Licensed under the LGPLv3 with static-linking exception.
-// See LICENCE file for details.
-
-package ratelimit
-
-import "io"
-
-type reader struct {
-	r      io.Reader
-	bucket *Bucket
-}
-
-// Reader returns a reader that is rate limited by
-// the given token bucket. Each token in the bucket
-// represents one byte.
-func Reader(r io.Reader, bucket *Bucket) io.Reader {
-	return &reader{
-		r:      r,
-		bucket: bucket,
-	}
-}
-
-func (r *reader) Read(buf []byte) (int, error) {
-	n, err := r.r.Read(buf)
-	if n <= 0 {
-		return n, err
-	}
-	r.bucket.Wait(int64(n))
-	return n, err
-}
-
-type writer struct {
-	w      io.Writer
-	bucket *Bucket
-}
-
-// Writer returns a reader that is rate limited by
-// the given token bucket. Each token in the bucket
-// represents one byte.
-func Writer(w io.Writer, bucket *Bucket) io.Writer {
-	return &writer{
-		w:      w,
-		bucket: bucket,
-	}
-}
-
-func (w *writer) Write(buf []byte) (int, error) {
-	w.bucket.Wait(int64(len(buf)))
-	return w.w.Write(buf)
-}

1.4/vendor/github.com/spf13/pflag/.travis.yml

@@ -1,17 +0,0 @@
-sudo: false
-
-language: go
-
-go:
-        - 1.5.4
-        - 1.6.3
-        - tip
-
-install:
-        - go get github.com/golang/lint/golint
-        - export PATH=$GOPATH/bin:$PATH
-        - go install ./...
-
-script:
-        - verify/all.sh -v
-        - go test ./...

1.4/vendor/github.com/ugorji/go/codec/prebuild.sh

@@ -1,199 +0,0 @@
-#!/bin/bash
-
-# _needgen is a helper function to tell if we need to generate files for msgp, codecgen.
-_needgen() {
-    local a="$1"
-    zneedgen=0
-    if [[ ! -e "$a" ]]
-    then
-        zneedgen=1
-        echo 1
-        return 0
-    fi 
-    for i in `ls -1 *.go.tmpl gen.go values_test.go`
-    do
-        if [[ "$a" -ot "$i" ]]
-        then
-            zneedgen=1
-            echo 1
-            return 0
-        fi 
-    done 
-    echo 0
-}
-
-# _build generates fast-path.go and gen-helper.go.
-# 
-# It is needed because there is some dependency between the generated code
-# and the other classes. Consequently, we have to totally remove the 
-# generated files and put stubs in place, before calling "go run" again
-# to recreate them.
-_build() {
-    if ! [[ "${zforce}" == "1" ||
-                "1" == $( _needgen "fast-path.generated.go" ) ||
-                "1" == $( _needgen "gen-helper.generated.go" ) ||
-                "1" == $( _needgen "gen.generated.go" ) ||
-                1 == 0 ]]
-    then
-        return 0
-    fi 
-
-   # echo "Running prebuild"
-    if [ "${zbak}" == "1" ] 
-    then
-        # echo "Backing up old generated files"
-        _zts=`date '+%m%d%Y_%H%M%S'`
-        _gg=".generated.go"
-        [ -e "gen-helper${_gg}" ] && mv gen-helper${_gg} gen-helper${_gg}__${_zts}.bak
-        [ -e "fast-path${_gg}" ] && mv fast-path${_gg} fast-path${_gg}__${_zts}.bak
-        # [ -e "safe${_gg}" ] && mv safe${_gg} safe${_gg}__${_zts}.bak
-        # [ -e "unsafe${_gg}" ] && mv unsafe${_gg} unsafe${_gg}__${_zts}.bak
-    else 
-        rm -f fast-path.generated.go gen.generated.go gen-helper.generated.go \
-           *safe.generated.go *_generated_test.go *.generated_ffjson_expose.go
-    fi
-
-    cat > gen.generated.go <<EOF
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
-// Use of this source code is governed by a MIT license found in the LICENSE file.
-
-package codec
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED FROM gen-dec-(map|array).go.tmpl
-
-const genDecMapTmpl = \`
-EOF
-
-    cat >> gen.generated.go < gen-dec-map.go.tmpl
-
-    cat >> gen.generated.go <<EOF
-\`
-
-const genDecListTmpl = \`
-EOF
-
-    cat >> gen.generated.go < gen-dec-array.go.tmpl
-
-    cat >> gen.generated.go <<EOF
-\`
-
-EOF
-
-    cat > gen-from-tmpl.codec.generated.go <<EOF
-package codec 
-import "io"
-func GenInternalGoFile(r io.Reader, w io.Writer, safe bool) error {
-return genInternalGoFile(r, w, safe)
-}
-EOF
-    
-    cat > gen-from-tmpl.generated.go <<EOF
-//+build ignore
-
-package main
-
-//import "flag"
-import "ugorji.net/codec"
-import "os"
-
-func run(fnameIn, fnameOut string, safe bool) {
-fin, err := os.Open(fnameIn)
-if err != nil { panic(err) }
-defer fin.Close()
-fout, err := os.Create(fnameOut)
-if err != nil { panic(err) }
-defer fout.Close()
-err = codec.GenInternalGoFile(fin, fout, safe)
-if err != nil { panic(err) }
-}
-
-func main() {
-// do not make safe/unsafe variants. 
-// Instead, depend on escape analysis, and place string creation and usage appropriately.
-// run("unsafe.go.tmpl", "safe.generated.go", true)
-// run("unsafe.go.tmpl", "unsafe.generated.go", false)
-run("fast-path.go.tmpl", "fast-path.generated.go", false)
-run("gen-helper.go.tmpl", "gen-helper.generated.go", false)
-}
-
-EOF
-    go run -tags=notfastpath gen-from-tmpl.generated.go && \
-        rm -f gen-from-tmpl.*generated.go 
-}
-
-_codegenerators() {
-    if [[ $zforce == "1" || 
-                "1" == $( _needgen "values_codecgen${zsfx}" ) ||
-                "1" == $( _needgen "values_msgp${zsfx}" ) ||
-                "1" == $( _needgen "values_ffjson${zsfx}" ) ||
-                1 == 0 ]] 
-    then
-        # codecgen creates some temporary files in the directory (main, pkg).
-        # Consequently, we should start msgp and ffjson first, and also put a small time latency before
-        # starting codecgen.
-        # Without this, ffjson chokes on one of the temporary files from codecgen.
-        if [[ $zexternal == "1" ]]
-        then 
-            echo "ffjson ... " && \
-                ffjson -w values_ffjson${zsfx} $zfin &
-            zzzIdFF=$!
-            echo "msgp ... " && \
-                msgp -tests=false -o=values_msgp${zsfx} -file=$zfin &
-            zzzIdMsgp=$!
-            
-            sleep 1 # give ffjson and msgp some buffer time. see note above.
-        fi
-        
-        echo "codecgen - !unsafe ... " && \
-            codecgen -rt codecgen -t 'x,codecgen,!unsafe' -o values_codecgen${zsfx} -d 19780 $zfin &
-        zzzIdC=$!
-        echo "codecgen - unsafe ... " && \
-            codecgen  -u -rt codecgen -t 'x,codecgen,unsafe' -o values_codecgen_unsafe${zsfx} -d 19781 $zfin &
-        zzzIdCU=$!
-        wait $zzzIdC $zzzIdCU $zzzIdMsgp $zzzIdFF && \
-            # remove (M|Unm)arshalJSON implementations, so they don't conflict with encoding/json bench \
-            if [[ $zexternal == "1" ]]
-            then
-                sed -i 's+ MarshalJSON(+ _MarshalJSON(+g' values_ffjson${zsfx} && \
-                    sed -i 's+ UnmarshalJSON(+ _UnmarshalJSON(+g' values_ffjson${zsfx}
-            fi && \
-            echo "generators done!" && \
-            true
-    fi 
-}
-
-# _init reads the arguments and sets up the flags
-_init() {
-OPTIND=1
-while getopts "fbx" flag
-do
-    case "x$flag" in 
-        'xf') zforce=1;;
-        'xb') zbak=1;;
-        'xx') zexternal=1;;
-        *) echo "prebuild.sh accepts [-fb] only"; return 1;;
-    esac
-done
-shift $((OPTIND-1))
-OPTIND=1
-}
-
-# main script.
-# First ensure that this is being run from the basedir (i.e. dirname of script is .)
-if [ "." = `dirname $0` ]
-then
-    zmydir=`pwd`
-    zfin="test_values.generated.go"
-    zsfx="_generated_test.go"
-    # rm -f *_generated_test.go 
-    rm -f codecgen-*.go && \
-        _init "$@" && \
-        _build && \
-        cp $zmydir/values_test.go $zmydir/$zfin && \
-        _codegenerators && \
-        echo prebuild done successfully
-    rm -f $zmydir/$zfin
-else
-    echo "Script must be run from the directory it resides in"
-fi 
-

1.4/vendor/github.com/ugorji/go/codec/test-cbor-goldens.json

@@ -1,639 +0,0 @@
-[
-  {
-    "cbor": "AA==",
-    "hex": "00",
-    "roundtrip": true,
-    "decoded": 0
-  },
-  {
-    "cbor": "AQ==",
-    "hex": "01",
-    "roundtrip": true,
-    "decoded": 1
-  },
-  {
-    "cbor": "Cg==",
-    "hex": "0a",
-    "roundtrip": true,
-    "decoded": 10
-  },
-  {
-    "cbor": "Fw==",
-    "hex": "17",
-    "roundtrip": true,
-    "decoded": 23
-  },
-  {
-    "cbor": "GBg=",
-    "hex": "1818",
-    "roundtrip": true,
-    "decoded": 24
-  },
-  {
-    "cbor": "GBk=",
-    "hex": "1819",
-    "roundtrip": true,
-    "decoded": 25
-  },
-  {
-    "cbor": "GGQ=",
-    "hex": "1864",
-    "roundtrip": true,
-    "decoded": 100
-  },
-  {
-    "cbor": "GQPo",
-    "hex": "1903e8",
-    "roundtrip": true,
-    "decoded": 1000
-  },
-  {
-    "cbor": "GgAPQkA=",
-    "hex": "1a000f4240",
-    "roundtrip": true,
-    "decoded": 1000000
-  },
-  {
-    "cbor": "GwAAAOjUpRAA",
-    "hex": "1b000000e8d4a51000",
-    "roundtrip": true,
-    "decoded": 1000000000000
-  },
-  {
-    "cbor": "G///////////",
-    "hex": "1bffffffffffffffff",
-    "roundtrip": true,
-    "decoded": 18446744073709551615
-  },
-  {
-    "cbor": "wkkBAAAAAAAAAAA=",
-    "hex": "c249010000000000000000",
-    "roundtrip": true,
-    "decoded": 18446744073709551616
-  },
-  {
-    "cbor": "O///////////",
-    "hex": "3bffffffffffffffff",
-    "roundtrip": true,
-    "decoded": -18446744073709551616,
-    "skip": true
-  },
-  {
-    "cbor": "w0kBAAAAAAAAAAA=",
-    "hex": "c349010000000000000000",
-    "roundtrip": true,
-    "decoded": -18446744073709551617
-  },
-  {
-    "cbor": "IA==",
-    "hex": "20",
-    "roundtrip": true,
-    "decoded": -1
-  },
-  {
-    "cbor": "KQ==",
-    "hex": "29",
-    "roundtrip": true,
-    "decoded": -10
-  },
-  {
-    "cbor": "OGM=",
-    "hex": "3863",
-    "roundtrip": true,
-    "decoded": -100
-  },
-  {
-    "cbor": "OQPn",
-    "hex": "3903e7",
-    "roundtrip": true,
-    "decoded": -1000
-  },
-  {
-    "cbor": "+QAA",
-    "hex": "f90000",
-    "roundtrip": true,
-    "decoded": 0.0
-  },
-  {
-    "cbor": "+YAA",
-    "hex": "f98000",
-    "roundtrip": true,
-    "decoded": -0.0
-  },
-  {
-    "cbor": "+TwA",
-    "hex": "f93c00",
-    "roundtrip": true,
-    "decoded": 1.0
-  },
-  {
-    "cbor": "+z/xmZmZmZma",
-    "hex": "fb3ff199999999999a",
-    "roundtrip": true,
-    "decoded": 1.1
-  },
-  {
-    "cbor": "+T4A",
-    "hex": "f93e00",
-    "roundtrip": true,
-    "decoded": 1.5
-  },
-  {
-    "cbor": "+Xv/",
-    "hex": "f97bff",
-    "roundtrip": true,
-    "decoded": 65504.0
-  },
-  {
-    "cbor": "+kfDUAA=",
-    "hex": "fa47c35000",
-    "roundtrip": true,
-    "decoded": 100000.0
-  },
-  {
-    "cbor": "+n9///8=",
-    "hex": "fa7f7fffff",
-    "roundtrip": true,
-    "decoded": 3.4028234663852886e+38
-  },
-  {
-    "cbor": "+3435DyIAHWc",
-    "hex": "fb7e37e43c8800759c",
-    "roundtrip": true,
-    "decoded": 1.0e+300
-  },
-  {
-    "cbor": "+QAB",
-    "hex": "f90001",
-    "roundtrip": true,
-    "decoded": 5.960464477539063e-08
-  },
-  {
-    "cbor": "+QQA",
-    "hex": "f90400",
-    "roundtrip": true,
-    "decoded": 6.103515625e-05
-  },
-  {
-    "cbor": "+cQA",
-    "hex": "f9c400",
-    "roundtrip": true,
-    "decoded": -4.0
-  },
-  {
-    "cbor": "+8AQZmZmZmZm",
-    "hex": "fbc010666666666666",
-    "roundtrip": true,
-    "decoded": -4.1
-  },
-  {
-    "cbor": "+XwA",
-    "hex": "f97c00",
-    "roundtrip": true,
-    "diagnostic": "Infinity"
-  },
-  {
-    "cbor": "+X4A",
-    "hex": "f97e00",
-    "roundtrip": true,
-    "diagnostic": "NaN"
-  },
-  {
-    "cbor": "+fwA",
-    "hex": "f9fc00",
-    "roundtrip": true,
-    "diagnostic": "-Infinity"
-  },
-  {
-    "cbor": "+n+AAAA=",
-    "hex": "fa7f800000",
-    "roundtrip": false,
-    "diagnostic": "Infinity"
-  },
-  {
-    "cbor": "+n/AAAA=",
-    "hex": "fa7fc00000",
-    "roundtrip": false,
-    "diagnostic": "NaN"
-  },
-  {
-    "cbor": "+v+AAAA=",
-    "hex": "faff800000",
-    "roundtrip": false,
-    "diagnostic": "-Infinity"
-  },
-  {
-    "cbor": "+3/wAAAAAAAA",
-    "hex": "fb7ff0000000000000",
-    "roundtrip": false,
-    "diagnostic": "Infinity"
-  },
-  {
-    "cbor": "+3/4AAAAAAAA",
-    "hex": "fb7ff8000000000000",
-    "roundtrip": false,
-    "diagnostic": "NaN"
-  },
-  {
-    "cbor": "+//wAAAAAAAA",
-    "hex": "fbfff0000000000000",
-    "roundtrip": false,
-    "diagnostic": "-Infinity"
-  },
-  {
-    "cbor": "9A==",
-    "hex": "f4",
-    "roundtrip": true,
-    "decoded": false
-  },
-  {
-    "cbor": "9Q==",
-    "hex": "f5",
-    "roundtrip": true,
-    "decoded": true
-  },
-  {
-    "cbor": "9g==",
-    "hex": "f6",
-    "roundtrip": true,
-    "decoded": null
-  },
-  {
-    "cbor": "9w==",
-    "hex": "f7",
-    "roundtrip": true,
-    "diagnostic": "undefined"
-  },
-  {
-    "cbor": "8A==",
-    "hex": "f0",
-    "roundtrip": true,
-    "diagnostic": "simple(16)"
-  },
-  {
-    "cbor": "+Bg=",
-    "hex": "f818",
-    "roundtrip": true,
-    "diagnostic": "simple(24)"
-  },
-  {
-    "cbor": "+P8=",
-    "hex": "f8ff",
-    "roundtrip": true,
-    "diagnostic": "simple(255)"
-  },
-  {
-    "cbor": "wHQyMDEzLTAzLTIxVDIwOjA0OjAwWg==",
-    "hex": "c074323031332d30332d32315432303a30343a30305a",
-    "roundtrip": true,
-    "diagnostic": "0(\"2013-03-21T20:04:00Z\")"
-  },
-  {
-    "cbor": "wRpRS2ew",
-    "hex": "c11a514b67b0",
-    "roundtrip": true,
-    "diagnostic": "1(1363896240)"
-  },
-  {
-    "cbor": "wftB1FLZ7CAAAA==",
-    "hex": "c1fb41d452d9ec200000",
-    "roundtrip": true,
-    "diagnostic": "1(1363896240.5)"
-  },
-  {
-    "cbor": "10QBAgME",
-    "hex": "d74401020304",
-    "roundtrip": true,
-    "diagnostic": "23(h'01020304')"
-  },
-  {
-    "cbor": "2BhFZElFVEY=",
-    "hex": "d818456449455446",
-    "roundtrip": true,
-    "diagnostic": "24(h'6449455446')"
-  },
-  {
-    "cbor": "2CB2aHR0cDovL3d3dy5leGFtcGxlLmNvbQ==",
-    "hex": "d82076687474703a2f2f7777772e6578616d706c652e636f6d",
-    "roundtrip": true,
-    "diagnostic": "32(\"http://www.example.com\")"
-  },
-  {
-    "cbor": "QA==",
-    "hex": "40",
-    "roundtrip": true,
-    "diagnostic": "h''"
-  },
-  {
-    "cbor": "RAECAwQ=",
-    "hex": "4401020304",
-    "roundtrip": true,
-    "diagnostic": "h'01020304'"
-  },
-  {
-    "cbor": "YA==",
-    "hex": "60",
-    "roundtrip": true,
-    "decoded": ""
-  },
-  {
-    "cbor": "YWE=",
-    "hex": "6161",
-    "roundtrip": true,
-    "decoded": "a"
-  },
-  {
-    "cbor": "ZElFVEY=",
-    "hex": "6449455446",
-    "roundtrip": true,
-    "decoded": "IETF"
-  },
-  {
-    "cbor": "YiJc",
-    "hex": "62225c",
-    "roundtrip": true,
-    "decoded": "\"\\"
-  },
-  {
-    "cbor": "YsO8",
-    "hex": "62c3bc",
-    "roundtrip": true,
-    "decoded": "ü"
-  },
-  {
-    "cbor": "Y+awtA==",
-    "hex": "63e6b0b4",
-    "roundtrip": true,
-    "decoded": "水"
-  },
-  {
-    "cbor": "ZPCQhZE=",
-    "hex": "64f0908591",
-    "roundtrip": true,
-    "decoded": "𐅑"
-  },
-  {
-    "cbor": "gA==",
-    "hex": "80",
-    "roundtrip": true,
-    "decoded": [
-
-    ]
-  },
-  {
-    "cbor": "gwECAw==",
-    "hex": "83010203",
-    "roundtrip": true,
-    "decoded": [
-      1,
-      2,
-      3
-    ]
-  },
-  {
-    "cbor": "gwGCAgOCBAU=",
-    "hex": "8301820203820405",
-    "roundtrip": true,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "mBkBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgYGBk=",
-    "hex": "98190102030405060708090a0b0c0d0e0f101112131415161718181819",
-    "roundtrip": true,
-    "decoded": [
-      1,
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-      10,
-      11,
-      12,
-      13,
-      14,
-      15,
-      16,
-      17,
-      18,
-      19,
-      20,
-      21,
-      22,
-      23,
-      24,
-      25
-    ]
-  },
-  {
-    "cbor": "oA==",
-    "hex": "a0",
-    "roundtrip": true,
-    "decoded": {
-    }
-  },
-  {
-    "cbor": "ogECAwQ=",
-    "hex": "a201020304",
-    "roundtrip": true,
-    "skip": true,
-    "diagnostic": "{1: 2, 3: 4}"
-  },
-  {
-    "cbor": "omFhAWFiggID",
-    "hex": "a26161016162820203",
-    "roundtrip": true,
-    "decoded": {
-      "a": 1,
-      "b": [
-        2,
-        3
-      ]
-    }
-  },
-  {
-    "cbor": "gmFhoWFiYWM=",
-    "hex": "826161a161626163",
-    "roundtrip": true,
-    "decoded": [
-      "a",
-      {
-        "b": "c"
-      }
-    ]
-  },
-  {
-    "cbor": "pWFhYUFhYmFCYWNhQ2FkYURhZWFF",
-    "hex": "a56161614161626142616361436164614461656145",
-    "roundtrip": true,
-    "decoded": {
-      "a": "A",
-      "b": "B",
-      "c": "C",
-      "d": "D",
-      "e": "E"
-    }
-  },
-  {
-    "cbor": "X0IBAkMDBAX/",
-    "hex": "5f42010243030405ff",
-    "roundtrip": false,
-    "skip": true,
-    "diagnostic": "(_ h'0102', h'030405')"
-  },
-  {
-    "cbor": "f2VzdHJlYWRtaW5n/w==",
-    "hex": "7f657374726561646d696e67ff",
-    "roundtrip": false,
-    "decoded": "streaming"
-  },
-  {
-    "cbor": "n/8=",
-    "hex": "9fff",
-    "roundtrip": false,
-    "decoded": [
-
-    ]
-  },
-  {
-    "cbor": "nwGCAgOfBAX//w==",
-    "hex": "9f018202039f0405ffff",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "nwGCAgOCBAX/",
-    "hex": "9f01820203820405ff",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "gwGCAgOfBAX/",
-    "hex": "83018202039f0405ff",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "gwGfAgP/ggQF",
-    "hex": "83019f0203ff820405",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "nwECAwQFBgcICQoLDA0ODxAREhMUFRYXGBgYGf8=",
-    "hex": "9f0102030405060708090a0b0c0d0e0f101112131415161718181819ff",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-      10,
-      11,
-      12,
-      13,
-      14,
-      15,
-      16,
-      17,
-      18,
-      19,
-      20,
-      21,
-      22,
-      23,
-      24,
-      25
-    ]
-  },
-  {
-    "cbor": "v2FhAWFinwID//8=",
-    "hex": "bf61610161629f0203ffff",
-    "roundtrip": false,
-    "decoded": {
-      "a": 1,
-      "b": [
-        2,
-        3
-      ]
-    }
-  },
-  {
-    "cbor": "gmFhv2FiYWP/",
-    "hex": "826161bf61626163ff",
-    "roundtrip": false,
-    "decoded": [
-      "a",
-      {
-        "b": "c"
-      }
-    ]
-  },
-  {
-    "cbor": "v2NGdW71Y0FtdCH/",
-    "hex": "bf6346756ef563416d7421ff",
-    "roundtrip": false,
-    "decoded": {
-      "Fun": true,
-      "Amt": -2
-    }
-  }
-]

1.4/vendor/github.com/ugorji/go/codec/tests.sh

@@ -1,74 +0,0 @@
-#!/bin/bash
-
-# Run all the different permutations of all the tests.
-# This helps ensure that nothing gets broken.
-
-_run() {
-    # 1. VARIATIONS: regular (t), canonical (c), IO R/W (i),
-    #                binc-nosymbols (n), struct2array (s), intern string (e),
-    # 2. MODE: reflection (r), external (x), codecgen (g), unsafe (u), notfastpath (f)
-    # 3. OPTIONS: verbose (v), reset (z), must (m),
-    # 
-    # Use combinations of mode to get exactly what you want,
-    # and then pass the variations you need.
-
-    ztags=""
-    zargs=""
-    local OPTIND 
-    OPTIND=1
-    while getopts "xurtcinsvgzmef" flag
-    do
-        case "x$flag" in 
-            'xr')  ;;
-            'xf') ztags="$ztags notfastpath" ;;
-            'xg') ztags="$ztags codecgen" ;;
-            'xx') ztags="$ztags x" ;;
-            'xu') ztags="$ztags unsafe" ;;
-            'xv') zargs="$zargs -tv" ;;
-            'xz') zargs="$zargs -tr" ;;
-            'xm') zargs="$zargs -tm" ;;
-            *) ;;
-        esac
-    done
-    # shift $((OPTIND-1))
-    printf '............. TAGS: %s .............\n' "$ztags"
-    # echo ">>>>>>> TAGS: $ztags"
-    
-    OPTIND=1
-    while getopts "xurtcinsvgzmef" flag
-    do
-        case "x$flag" in 
-            'xt') printf ">>>>>>> REGULAR    : "; go test "-tags=$ztags" $zargs ; sleep 2 ;;
-            'xc') printf ">>>>>>> CANONICAL  : "; go test "-tags=$ztags" $zargs -tc; sleep 2 ;;
-            'xi') printf ">>>>>>> I/O        : "; go test "-tags=$ztags" $zargs -ti; sleep 2 ;;
-            'xn') printf ">>>>>>> NO_SYMBOLS : "; go test "-tags=$ztags" $zargs -tn; sleep 2 ;;
-            'xs') printf ">>>>>>> TO_ARRAY   : "; go test "-tags=$ztags" $zargs -ts; sleep 2 ;;
-            'xe') printf ">>>>>>> INTERN     : "; go test "-tags=$ztags" $zargs -te; sleep 2 ;;
-            *) ;;
-        esac
-    done
-    shift $((OPTIND-1))
-
-    OPTIND=1
-}
-
-# echo ">>>>>>> RUNNING VARIATIONS OF TESTS"    
-if [[ "x$@" = "x" ]]; then
-    # All: r, x, g, gu
-    _run "-rtcinsm"  # regular
-    _run "-rtcinsmz" # regular with reset
-    _run "-rtcinsmf" # regular with no fastpath (notfastpath)
-    _run "-xtcinsm" # external
-    _run "-gxtcinsm" # codecgen: requires external
-    _run "-gxutcinsm" # codecgen + unsafe
-elif [[ "x$@" = "x-Z" ]]; then
-    # Regular
-    _run "-rtcinsm"  # regular
-    _run "-rtcinsmz" # regular with reset
-elif [[ "x$@" = "x-F" ]]; then
-    # regular with notfastpath
-    _run "-rtcinsmf"  # regular
-    _run "-rtcinsmzf" # regular with reset
-else
-    _run "$@"
-fi

CHANGELOG.md

@@ -0,0 +1,7 @@
+# v1.5.0
+
+## Changelog since v1.4.0
+
+### Added
+* Include the auth plugin (https://github.com/kubernetes/kubernetes/pull/33334)
+* Add timeout field to RESTClient config (https://github.com/kubernetes/kubernetes/pull/33958)

Godeps/Godeps.json

@@ -0,0 +1,331 @@
+{
+	"ImportPath": "k8s.io/client-go",
+	"GoVersion": "go1.7",
+	"GodepVersion": "v75",
+	"Packages": [
+		"./..."
+	],
+	"Deps": [
+		{
+			"ImportPath": "cloud.google.com/go/compute/metadata",
+			"Comment": "v0.1.0-115-g3b1ae45",
+			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
+		},
+		{
+			"ImportPath": "cloud.google.com/go/internal",
+			"Comment": "v0.1.0-115-g3b1ae45",
+			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
+		},
+		{
+			"ImportPath": "github.com/PuerkitoBio/purell",
+			"Comment": "v1.0.0",
+			"Rev": "8a290539e2e8629dbc4e6bad948158f790ec31f4"
+		},
+		{
+			"ImportPath": "github.com/PuerkitoBio/urlesc",
+			"Rev": "5bd2802263f21d8788851d5305584c82a5c75d7e"
+		},
+		{
+			"ImportPath": "github.com/blang/semver",
+			"Comment": "v3.0.1",
+			"Rev": "31b736133b98f26d5e078ec9eb591666edfd091f"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/http",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/jose",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/key",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/oauth2",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/oidc",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/pkg/health",
+			"Comment": "v2-8-gfa29b1d",
+			"Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
+		},
+		{
+			"ImportPath": "github.com/coreos/pkg/httputil",
+			"Comment": "v2-8-gfa29b1d",
+			"Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
+		},
+		{
+			"ImportPath": "github.com/coreos/pkg/timeutil",
+			"Comment": "v2-8-gfa29b1d",
+			"Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
+		},
+		{
+			"ImportPath": "github.com/davecgh/go-spew/spew",
+			"Rev": "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d"
+		},
+		{
+			"ImportPath": "github.com/docker/distribution/digest",
+			"Comment": "v2.4.0-rc.1-38-gcd27f17",
+			"Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
+		},
+		{
+			"ImportPath": "github.com/docker/distribution/reference",
+			"Comment": "v2.4.0-rc.1-38-gcd27f17",
+			"Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
+		},
+		{
+			"ImportPath": "github.com/docker/spdystream",
+			"Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
+		},
+		{
+			"ImportPath": "github.com/docker/spdystream/spdy",
+			"Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
+		},
+		{
+			"ImportPath": "github.com/emicklei/go-restful",
+			"Comment": "v1.2-79-g89ef8af",
+			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+		},
+		{
+			"ImportPath": "github.com/emicklei/go-restful/log",
+			"Comment": "v1.2-79-g89ef8af",
+			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+		},
+		{
+			"ImportPath": "github.com/emicklei/go-restful/swagger",
+			"Comment": "v1.2-79-g89ef8af",
+			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+		},
+		{
+			"ImportPath": "github.com/ghodss/yaml",
+			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
+		},
+		{
+			"ImportPath": "github.com/go-openapi/jsonpointer",
+			"Rev": "46af16f9f7b149af66e5d1bd010e3574dc06de98"
+		},
+		{
+			"ImportPath": "github.com/go-openapi/jsonreference",
+			"Rev": "13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272"
+		},
+		{
+			"ImportPath": "github.com/go-openapi/spec",
+			"Rev": "6aced65f8501fe1217321abf0749d354824ba2ff"
+		},
+		{
+			"ImportPath": "github.com/go-openapi/swag",
+			"Rev": "1d0bd113de87027671077d3c71eb3ac5d7dbba72"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/proto",
+			"Comment": "v0.2-33-ge18d7aa",
+			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/sortkeys",
+			"Comment": "v0.2-33-ge18d7aa",
+			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
+		},
+		{
+			"ImportPath": "github.com/golang/glog",
+			"Rev": "44145f04b68cf362d9c4df2182967c2275eaefed"
+		},
+		{
+			"ImportPath": "github.com/golang/groupcache/lru",
+			"Rev": "02826c3e79038b59d737d3b1c0a1d937f71a4433"
+		},
+		{
+			"ImportPath": "github.com/golang/protobuf/proto",
+			"Rev": "8616e8ee5e20a1704615e6c8d7afcdac06087a67"
+		},
+		{
+			"ImportPath": "github.com/google/gofuzz",
+			"Rev": "bbcb9da2d746f8bdbd6a936686a0a6067ada0ec5"
+		},
+		{
+			"ImportPath": "github.com/howeyc/gopass",
+			"Rev": "3ca23474a7c7203e0a0a070fd33508f6efdb9b3d"
+		},
+		{
+			"ImportPath": "github.com/imdario/mergo",
+			"Comment": "0.1.3-8-g6633656",
+			"Rev": "6633656539c1639d9d78127b7d47c622b5d7b6dc"
+		},
+		{
+			"ImportPath": "github.com/jonboulle/clockwork",
+			"Rev": "72f9bd7c4e0c2a40055ab3d0f09654f730cce982"
+		},
+		{
+			"ImportPath": "github.com/mailru/easyjson/buffer",
+			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
+		},
+		{
+			"ImportPath": "github.com/mailru/easyjson/jlexer",
+			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
+		},
+		{
+			"ImportPath": "github.com/mailru/easyjson/jwriter",
+			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
+		},
+		{
+			"ImportPath": "github.com/pborman/uuid",
+			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
+		},
+		{
+			"ImportPath": "github.com/pmezard/go-difflib/difflib",
+			"Rev": "d8ed2627bdf02c080bf22230dbb337003b7aba2d"
+		},
+		{
+			"ImportPath": "github.com/spf13/pflag",
+			"Rev": "5ccb023bc27df288a957c5e994cd44fd19619465"
+		},
+		{
+			"ImportPath": "github.com/stretchr/testify/assert",
+			"Comment": "v1.0-88-ge3a8ff8",
+			"Rev": "e3a8ff8ce36581f87a15341206f205b1da467059"
+		},
+		{
+			"ImportPath": "github.com/ugorji/go/codec",
+			"Rev": "f1f1a805ed361a0e078bb537e4ea78cd37dcf065"
+		},
+		{
+			"ImportPath": "golang.org/x/crypto/ssh/terminal",
+			"Rev": "1f22c0103821b9390939b6776727195525381532"
+		},
+		{
+			"ImportPath": "golang.org/x/net/context",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/context/ctxhttp",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/http2",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/http2/hpack",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/idna",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/lex/httplex",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/google",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/internal",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/jws",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/jwt",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/sys/unix",
+			"Rev": "8f0908ab3b2457e2e15403d3697c9ef5cb4b57a9"
+		},
+		{
+			"ImportPath": "golang.org/x/text/cases",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/internal/tag",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/language",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/runes",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/secure/bidirule",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/secure/precis",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/transform",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/unicode/bidi",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/unicode/norm",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/width",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/app_identity",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/base",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/datastore",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/log",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/modules",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/remote_api",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "gopkg.in/inf.v0",
+			"Comment": "v0.9.0",
+			"Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
+		},
+		{
+			"ImportPath": "gopkg.in/yaml.v2",
+			"Rev": "53feefa2559fb8dfa8d81baad31be332c97d6c77"
+		}
+	]
+}

README.md

@@ -2,6 +2,20 @@
 
 Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.
 
+## Table of Contents
+ 
+- [What's included](#whats-included)
+- [Versioning](#versioning)
+  - [Compatibility: your code <-> client-go](#compatibility-your-code---client-go)
+  - [Compatibility: client-go <-> Kubernetes clusters](#compatibility-client-go---kubernetes-clusters)
+  - [Compatibility matrix](#compatibility-matrix)
+  - [Why do the 1.4 and 1.5 branch contain top-level folder named after the version?](#why-do-the-14-and-15-branch-contain-top-level-folder-named-after-the-version)
+- [How to get it](#how-to-get-it)
+- [How to use it](#how-to-use-it)
+- [Dependency management](#dependency-management)
+- [Reporting bugs](#reporting-bugs)
+- [Contributing code](#contributing-code)
+
 ### What's included
 
 * The `kubernetes` package contains the clientset to access Kubernetes API.
@@ -10,15 +24,42 @@ Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.
 * The `transport` package is used to set up auth and start a connection.
 * The `tools/cache` package is useful for writing controllers.
 
-### Releases
+### Versioning
 
-Each top-level folder (e.g., 1.4) contains a release of clients and their dependencies.
+`client-go` version numbers are unrelated to Kubernetes version numbers. Please see the [compatibility matrix](#compatibility-matrix) for the compatible Kubernetes clusters.
 
-client-go has the same release cycle as the Kubernetes main repository. For example, in the 1.4 release cycle, the contents in `1.4/` folder are subjected to changes. Once 1.4 is released, new changes will go into the `1.5/` folder. We will make great efforts to not change the public interface of a version of the client once that version has been released. We may change the interface between versions. Old versions of the client will be retained for two release cycles.
+`client-go` follows [semver](http://semver.org/). We will not make backwards-incompatible changes without incrementing the major version number. A change is backwards-incompatible either if it *i)* changes the public interfaces of `client-go`, or *ii)* makes `client-go` incompatible with otherwise supported versions of Kubernetes clusters.
+
+We will create a new branch for each increment in the major version number or minor version number. We will create a new tag for each increment in the patch version number. See [semver](http://semver.org/) for definitions of major, minor, and patch.
+
+The master branch will track the head in the main Kubernetes repo and accumulating changes. We will make a new client-go major/minor/patch version when:
+* A new major (very rare) or a new minor version is released in the Kubernetes main repository.
+* A feature or a bug fix in the master branch is popular and users want it in a stable branch or with a stable tag. 
+
+#### Compatibility: your code <-> client-go
+
+`client-go` follows [semver](http://semver.org/), so until the major version of client-go gets increased, your code will compile and will continue to work with explicitly supported versions of Kubernetes clusters.
+
+#### Compatibility: client-go <-> Kubernetes clusters
+
+`client-go` versions will be backwards compatible with many Kubernetes clusters. As we increment `client-go` versions, we will note which Kubernetes versions we expect them to work with. 
+
+We do not back-port new Kubernetes features into older clients. If you need a new feature, you are expected to upgrade to the new client. You can check out the [CHANGELOG](./CHANGELOG.md) for notable changes.
+
+#### Compatibility matrix
+
+* **client-go/1.4** is compatible with Kubernetes 1.3 through 1.5; it includes all features provided by Kubernetes 1.4.
+* **client-go/1.5** is compatible with Kubernetes 1.3 through 1.5; it includes all features provided by Kubernetes 1.4.
+
+#### Why do the 1.4 and 1.5 branch contain top-level folder named after the version?
+
+1.4 and 1.5 branch keep the top-level folders so they do not break the import lines of existing users. These top-level folders are deprecated and are removed from the master branch and future branches.
 
 ### How to get it
 
-You can `go get` to get a release of client-go, e.g., `go get k8s.io/client-go/1.4/...` or `go get k8s.io/client-go/1.4/kubernetes`.
+If you use `go get` to get client-go, **you will get the unstable master branch!** You can `git checkout` a stable branch.
+
+We recommend using a vendor tool, like [godep](https://github.com/tools/godep), [glide](https://github.com/Masterminds/glide), or [govendor](https://github.com/kardianos/govendor) to track a stable version of `client-go`.
 
 ### How to use it
 
@@ -27,7 +68,7 @@ If your application runs in a Pod in the cluster, please refer to the in-cluster
 ### Dependency management
 
 If your application depends on a package that client-go depends on, and you let the Go compiler find the dependency in `GOPATH`, you will end up with duplicated dependencies: one copy from the `GOPATH`, and one from the vendor folder of client-go. This will cause unexpected runtime error like flag redefinition, since the go compiler ends up importing both packages separately, even if they are exactly the same thing. If this happens, you can either
-* run `godep restore` ([godep](https://github.com/tools/godep)) in the client-go/1.4 folder, then remove the vendor folder of client-go. Then the packages in your GOPATH will be the only copy
+* run `godep restore` ([godep](https://github.com/tools/godep)) in the client-go/ folder, then remove the vendor folder of client-go. Then the packages in your GOPATH will be the only copy
 * or run `godep save` in your application folder to flatten all dependencies.
 
 ### Reporting bugs
@@ -35,4 +76,4 @@ If your application depends on a package that client-go depends on, and you let
 Please report bugs to the main Kubernetes [repository](https://github.com/kubernetes/kubernetes/issues/new).
 
 ### Contributing code
-Please send pull requests against the client packages in the Kubernetes main [repository](https://github.com/kubernetes/kubernetes), and run the `/staging/src/k8s.io/client-go/copy.sh` script to update the staging area in the main repository. Changes in the staging area will be published to this repository every day.
+Please send pull requests against the client packages in the Kubernetes main [repository](https://github.com/kubernetes/kubernetes), and run the `/staging/copy.sh` script to update the staging area in the main repository. Changes in the staging area will be published to this repository every day.

copy.sh

@@ -1,163 +0,0 @@
-#!/bin/bash
-
-# 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.
-
-set -o errexit
-set -o nounset
-set -o pipefail
-
-# PREREQUISITES: run `godep restore` in the main repo before calling this script.
-RELEASE="1.4"
-MAIN_REPO_FROM_SRC="${1:-"k8s.io/kubernetes"}"
-MAIN_REPO="${GOPATH%:*}/src/${MAIN_REPO_FROM_SRC}"
-CLIENT_REPO_FROM_SRC="${2:-"k8s.io/client-go/${RELEASE}"}"
-CLIENT_REPO="${MAIN_REPO}/staging/src/${CLIENT_REPO_FROM_SRC}"
-CLIENT_REPO_TEMP="${CLIENT_REPO}"/_tmp
-
-DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# working in the ${CLIENT_REPO_TEMP} so 'godep save' won't complain about dirty working tree.
-echo "creating the _tmp directory"
-mkdir -p "${CLIENT_REPO_TEMP}"
-cd "${CLIENT_REPO}"
-
-# mkcp copies file from the main repo to the client repo, it creates the directory if it doesn't exist in the client repo.
-function mkcp() {
-    mkdir -p "${CLIENT_REPO_TEMP}/$2" && cp -r "${MAIN_REPO}/$1" "${CLIENT_REPO_TEMP}/$2"
-}
-
-echo "copying client packages"
-mkcp "pkg/client/clientset_generated/release_1_4" "pkg/client/clientset_generated"
-mkcp "/pkg/client/record/" "/pkg/client"
-mkcp "/pkg/client/cache/" "/pkg/client"
-# TODO: make this test file not depending on pkg/client/unversioned
-rm "${CLIENT_REPO_TEMP}"/pkg/client/cache/listwatch_test.go
-mkcp "/pkg/client/restclient" "/pkg/client"
-mkcp "/pkg/client/testing" "/pkg/client"
-# remove this test because it imports the internal clientset
-rm "${CLIENT_REPO_TEMP}"/pkg/client/testing/core/fake_test.go
-mkcp "/pkg/client/transport" "/pkg/client"
-mkcp "/pkg/client/typed" "/pkg/client"
-
-mkcp "/pkg/client/unversioned/auth" "/pkg/client/unversioned"
-mkcp "/pkg/client/unversioned/clientcmd" "/pkg/client/unversioned"
-mkcp "/pkg/client/unversioned/portforward" "/pkg/client/unversioned"
-# remove this test because it imports the internal clientset
-rm "${CLIENT_REPO_TEMP}"/pkg/client/unversioned/portforward/portforward_test.go
-
-pushd "${CLIENT_REPO_TEMP}" > /dev/null
-echo "generating vendor/"
-GO15VENDOREXPERIMENT=1 godep save ./...
-popd > /dev/null
-
-echo "move to the client repo"
-# clean the ${CLIENT_REPO}
-ls "${CLIENT_REPO}" | grep -v '_tmp' | xargs rm -r
-mv "${CLIENT_REPO_TEMP}"/* "${CLIENT_REPO}"
-rm -r "${CLIENT_REPO_TEMP}"
-
-echo "moving vendor/k8s.io/kuberentes"
-cp -rn "${CLIENT_REPO}"/vendor/k8s.io/kubernetes/. "${CLIENT_REPO}"/
-rm -rf "${CLIENT_REPO}"/vendor/k8s.io/kubernetes
-# client-go will share the vendor of the main repo for now. When client-go
-# becomes a standalone repo, it will have its own vendor
-mv "${CLIENT_REPO}"/vendor "${CLIENT_REPO}"/_vendor
-# remove the pkg/util/net/sets/README.md to silent hack/verify-munge-docs.sh
-# TODO: probably we should convert the README.md a doc.go
-find ./ -name "README.md" -delete
-
-echo "rewriting Godeps.json"
-go run "${DIR}/godeps-json-updater.go" --godeps-file="${CLIENT_REPO}/Godeps/Godeps.json" --client-go-import-path="${CLIENT_REPO_FROM_SRC}"
-
-echo "rewriting imports"
-grep -Rl "\"${MAIN_REPO_FROM_SRC}" ./ | grep ".go" | grep -v "vendor/" | xargs sed -i "s|\"${MAIN_REPO_FROM_SRC}|\"${CLIENT_REPO_FROM_SRC}|g"
-
-echo "converting pkg/client/record to v1"
-# need a v1 version of ref.go
-cp "${CLIENT_REPO}"/pkg/api/ref.go "${CLIENT_REPO}"/pkg/api/v1/ref.go
-gofmt -w -r 'api.a -> v1.a' "${CLIENT_REPO}"/pkg/api/v1/ref.go
-gofmt -w -r 'Scheme -> api.Scheme' "${CLIENT_REPO}"/pkg/api/v1/ref.go
-# rewriting package name to v1
-sed -i 's/package api/package v1/g' "${CLIENT_REPO}"/pkg/api/v1/ref.go
-# ref.go refers api.Scheme, so manually import /pkg/api
-sed -i "s,import (,import (\n\"${CLIENT_REPO_FROM_SRC}/pkg/api\",g" "${CLIENT_REPO}"/pkg/api/v1/ref.go
-gofmt -w "${CLIENT_REPO}"/pkg/api/v1/ref.go 
-# rewrite pkg/client/record to v1
-gofmt -w -r 'api.a -> v1.a' "${CLIENT_REPO}"/pkg/client/record
-# need to call sed to rewrite the strings in test cases...
-find "${CLIENT_REPO}"/pkg/client/record -type f -name "*.go" -print0 | xargs -0 sed -i "s/api.ObjectReference/v1.ObjectReference/g"
-# rewrite the imports
-find "${CLIENT_REPO}"/pkg/client/record -type f -name "*.go" -print0 | xargs -0 sed -i 's,pkg/api",pkg/api/v1",g'
-# gofmt the changed files
-
-echo "rewrite conflicting Prometheus registration"
-sed -i "s/request_latency_microseconds/request_latency_microseconds_copy/g" "${CLIENT_REPO}"/pkg/client/metrics/metrics.go
-sed -i "s/request_status_codes/request_status_codes_copy/g" "${CLIENT_REPO}"/pkg/client/metrics/metrics.go
-sed -i "s/kubernetes_build_info/kubernetes_build_info_copy/g" "${CLIENT_REPO}"/pkg/version/version.go
-
-echo "rewrite proto names in proto.RegisterType"
-find "${CLIENT_REPO}" -type f -name "generated.pb.go" -print0 | xargs -0 sed -i "s/k8s\.io\.kubernetes/k8s.io.client-go.1.4/g"
-
-echo "rearranging directory layout"
-# $1 and $2 are relative to ${CLIENT_REPO}
-function mvfolder {
-    local src=${1%/#/}
-    local dst=${2%/#/}
-    # create the parent directory of dst
-    if [ "${dst%/*}" != "${dst}" ]; then
-        mkdir -p "${CLIENT_REPO}/${dst%/*}"
-    fi
-    # move
-    mv "${CLIENT_REPO}/${src}" "${CLIENT_REPO}/${dst}"
-    # rewrite package
-    local src_package="${src##*/}"
-    local dst_package="${dst##*/}"
-    find "${CLIENT_REPO}" -type f -name "*.go" -print0 | xargs -0 sed -i "s,package ${src_package},package ${dst_package},g"
-    # rewrite imports
-    # the first rule is to convert import lines like `restclient "k8s.io/client-go/pkg/client/restclient"`,
-    # where a package alias is the same the package name.
-    find "${CLIENT_REPO}" -type f -name "*.go" -print0 | \
-        xargs -0 sed -i "s,${src_package} \"${CLIENT_REPO_FROM_SRC}/${src},${dst_package} \"${CLIENT_REPO_FROM_SRC}/${dst},g"
-    find "${CLIENT_REPO}" -type f -name "*.go" -print0 | \
-        xargs -0 sed -i "s,\"${CLIENT_REPO_FROM_SRC}/${src},\"${CLIENT_REPO_FROM_SRC}/${dst},g"
-    # rewrite import invocation
-    if [ "${src_package}" != "${dst_package}" ]; then
-        find "${CLIENT_REPO}" -type f -name "*.go" -print0 | xargs -0 sed -i "s,\<${src_package}\.\([a-zA-Z]\),${dst_package}\.\1,g"
-    fi
-}
-
-mvfolder pkg/client/clientset_generated/release_1_4 kubernetes
-mvfolder pkg/client/typed/discovery discovery
-mvfolder pkg/client/typed/dynamic dynamic
-mvfolder pkg/client/transport transport
-mvfolder pkg/client/record tools/record
-mvfolder pkg/client/restclient rest
-mvfolder pkg/client/cache tools/cache
-mvfolder pkg/client/unversioned/auth tools/auth
-mvfolder pkg/client/unversioned/clientcmd tools/clientcmd
-mvfolder pkg/client/unversioned/portforward tools/portforward
-mvfolder pkg/client/metrics tools/metrics
-mvfolder pkg/client/testing/core testing
-if [ "$(find "${CLIENT_REPO}"/pkg/client -type f -name "*.go")" ]; then
-    echo "${CLIENT_REPO}/pkg/client is expected to be empty"
-    exit 1
-else 
-    rm -r "${CLIENT_REPO}"/pkg/client
-fi
-mvfolder third_party pkg/third_party
-mvfolder federation pkg/federation
-
-echo "running gofmt"
-find "${CLIENT_REPO}" -type f -name "*.go" -print0 | xargs -0 gofmt -w

discovery/discovery_client.go

@@ -25,25 +25,35 @@ import (
 
 	"github.com/emicklei/go-restful/swagger"
 
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/errors"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/api/v1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/runtime/serializer"
-	"k8s.io/client-go/1.4/pkg/version"
-	"k8s.io/client-go/1.4/rest"
+	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/api/errors"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/pkg/runtime/serializer"
+	"k8s.io/client-go/pkg/version"
+	"k8s.io/client-go/rest"
 )
 
 // DiscoveryInterface holds the methods that discover server-supported API groups,
 // versions and resources.
 type DiscoveryInterface interface {
+	RESTClient() rest.Interface
 	ServerGroupsInterface
 	ServerResourcesInterface
 	ServerVersionInterface
 	SwaggerSchemaInterface
 }
 
+// CachedDiscoveryInterface is a DiscoveryInterface with cache invalidation and freshness.
+type CachedDiscoveryInterface interface {
+	DiscoveryInterface
+	// Fresh returns true if no cached data was used that had been retrieved before the instantiation.
+	Fresh() bool
+	// Invalidate enforces that no cached data is used in the future that is older than the current time.
+	Invalidate()
+}
+
 // ServerGroupsInterface has methods for obtaining supported groups on the API server
 type ServerGroupsInterface interface {
 	// ServerGroups returns the supported groups, with information like supported versions and the
@@ -80,7 +90,7 @@ type SwaggerSchemaInterface interface {
 // DiscoveryClient implements the functions that discover server-supported API groups,
 // versions and resources.
 type DiscoveryClient struct {
-	*rest.RESTClient
+	restClient rest.Interface
 
 	LegacyPrefix string
 }
@@ -107,7 +117,7 @@ func apiVersionsToAPIGroup(apiVersions *unversioned.APIVersions) (apiGroup unver
 func (d *DiscoveryClient) ServerGroups() (apiGroupList *unversioned.APIGroupList, err error) {
 	// Get the groupVersions exposed at /api
 	v := &unversioned.APIVersions{}
-	err = d.Get().AbsPath(d.LegacyPrefix).Do().Into(v)
+	err = d.restClient.Get().AbsPath(d.LegacyPrefix).Do().Into(v)
 	apiGroup := unversioned.APIGroup{}
 	if err == nil {
 		apiGroup = apiVersionsToAPIGroup(v)
@@ -118,7 +128,7 @@ func (d *DiscoveryClient) ServerGroups() (apiGroupList *unversioned.APIGroupList
 
 	// Get the groupVersions exposed at /apis
 	apiGroupList = &unversioned.APIGroupList{}
-	err = d.Get().AbsPath("/apis").Do().Into(apiGroupList)
+	err = d.restClient.Get().AbsPath("/apis").Do().Into(apiGroupList)
 	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
 		return nil, err
 	}
@@ -144,7 +154,7 @@ func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (r
 		url.Path = "/apis/" + groupVersion
 	}
 	resources = &unversioned.APIResourceList{}
-	err = d.Get().AbsPath(url.String()).Do().Into(resources)
+	err = d.restClient.Get().AbsPath(url.String()).Do().Into(resources)
 	if err != nil {
 		// ignore 403 or 404 error to be compatible with an v1.0 server.
 		if groupVersion == "v1" && (errors.IsNotFound(err) || errors.IsForbidden(err)) {
@@ -199,39 +209,46 @@ func IsGroupDiscoveryFailedError(err error) bool {
 // serverPreferredResources returns the supported resources with the version preferred by the
 // server. If namespaced is true, only namespaced resources will be returned.
 func (d *DiscoveryClient) serverPreferredResources(namespaced bool) ([]unversioned.GroupVersionResource, error) {
-	results := []unversioned.GroupVersionResource{}
-	serverGroupList, err := d.ServerGroups()
-	if err != nil {
-		return results, err
-	}
-
+	// retry in case the groups supported by the server change after ServerGroup() returns.
+	const maxRetries = 2
 	var failedGroups map[unversioned.GroupVersion]error
-	for _, apiGroup := range serverGroupList.Groups {
-		preferredVersion := apiGroup.PreferredVersion
-		groupVersion := unversioned.GroupVersion{Group: apiGroup.Name, Version: preferredVersion.Version}
-		apiResourceList, err := d.ServerResourcesForGroupVersion(preferredVersion.GroupVersion)
+	var results []unversioned.GroupVersionResource
+RetrieveGroups:
+	for i := 0; i < maxRetries; i++ {
+		results = []unversioned.GroupVersionResource{}
+		failedGroups = make(map[unversioned.GroupVersion]error)
+		serverGroupList, err := d.ServerGroups()
 		if err != nil {
-			if failedGroups == nil {
-				failedGroups = make(map[unversioned.GroupVersion]error)
-			}
-			failedGroups[groupVersion] = err
-			continue
+			return results, err
 		}
-		for _, apiResource := range apiResourceList.APIResources {
-			// ignore the root scoped resources if "namespaced" is true.
-			if namespaced && !apiResource.Namespaced {
+
+		for _, apiGroup := range serverGroupList.Groups {
+			preferredVersion := apiGroup.PreferredVersion
+			groupVersion := unversioned.GroupVersion{Group: apiGroup.Name, Version: preferredVersion.Version}
+			apiResourceList, err := d.ServerResourcesForGroupVersion(preferredVersion.GroupVersion)
+			if err != nil {
+				if i < maxRetries-1 {
+					continue RetrieveGroups
+				}
+				failedGroups[groupVersion] = err
 				continue
 			}
-			if strings.Contains(apiResource.Name, "/") {
-				continue
+			for _, apiResource := range apiResourceList.APIResources {
+				// ignore the root scoped resources if "namespaced" is true.
+				if namespaced && !apiResource.Namespaced {
+					continue
+				}
+				if strings.Contains(apiResource.Name, "/") {
+					continue
+				}
+				results = append(results, groupVersion.WithResource(apiResource.Name))
 			}
-			results = append(results, groupVersion.WithResource(apiResource.Name))
+		}
+		if len(failedGroups) == 0 {
+			return results, nil
 		}
 	}
-	if len(failedGroups) > 0 {
-		return results, &ErrGroupDiscoveryFailed{Groups: failedGroups}
-	}
-	return results, nil
+	return results, &ErrGroupDiscoveryFailed{Groups: failedGroups}
 }
 
 // ServerPreferredResources returns the supported resources with the version preferred by the
@@ -248,7 +265,7 @@ func (d *DiscoveryClient) ServerPreferredNamespacedResources() ([]unversioned.Gr
 
 // ServerVersion retrieves and parses the server's version (git version).
 func (d *DiscoveryClient) ServerVersion() (*version.Info, error) {
-	body, err := d.Get().AbsPath("/version").Do().Raw()
+	body, err := d.restClient.Get().AbsPath("/version").Do().Raw()
 	if err != nil {
 		return nil, err
 	}
@@ -282,7 +299,7 @@ func (d *DiscoveryClient) SwaggerSchema(version unversioned.GroupVersion) (*swag
 		path = "/swaggerapi/apis/" + version.Group + "/" + version.Version
 	}
 
-	body, err := d.Get().AbsPath(path).Do().Raw()
+	body, err := d.restClient.Get().AbsPath(path).Do().Raw()
 	if err != nil {
 		return nil, err
 	}
@@ -298,10 +315,7 @@ func setDiscoveryDefaults(config *rest.Config) error {
 	config.APIPath = ""
 	config.GroupVersion = nil
 	codec := runtime.NoopEncoder{Decoder: api.Codecs.UniversalDecoder()}
-	config.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(
-		runtime.SerializerInfo{Serializer: codec},
-		runtime.StreamSerializerInfo{},
-	)
+	config.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec})
 	if len(config.UserAgent) == 0 {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
 	}
@@ -316,7 +330,7 @@ func NewDiscoveryClientForConfig(c *rest.Config) (*DiscoveryClient, error) {
 		return nil, err
 	}
 	client, err := rest.UnversionedRESTClientFor(&config)
-	return &DiscoveryClient{RESTClient: client, LegacyPrefix: "/api"}, err
+	return &DiscoveryClient{restClient: client, LegacyPrefix: "/api"}, err
 }
 
 // NewDiscoveryClientForConfig creates a new DiscoveryClient for the given config. If
@@ -331,8 +345,8 @@ func NewDiscoveryClientForConfigOrDie(c *rest.Config) *DiscoveryClient {
 }
 
 // New creates a new DiscoveryClient for the given RESTClient.
-func NewDiscoveryClient(c *rest.RESTClient) *DiscoveryClient {
-	return &DiscoveryClient{RESTClient: c, LegacyPrefix: "/api"}
+func NewDiscoveryClient(c rest.Interface) *DiscoveryClient {
+	return &DiscoveryClient{restClient: c, LegacyPrefix: "/api"}
 }
 
 func stringDoesntExistIn(str string, slice []string) bool {
@@ -343,3 +357,12 @@ func stringDoesntExistIn(str string, slice []string) bool {
 	}
 	return true
 }
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *DiscoveryClient) RESTClient() rest.Interface {
+	if c == nil {
+		return nil
+	}
+	return c.restClient
+}

discovery/discovery_client_test.go

@@ -25,10 +25,10 @@ import (
 
 	"github.com/emicklei/go-restful/swagger"
 
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/api/v1"
-	"k8s.io/client-go/1.4/pkg/version"
-	"k8s.io/client-go/1.4/rest"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/pkg/version"
+	"k8s.io/client-go/rest"
 )
 
 func TestGetServerVersion(t *testing.T) {
@@ -454,3 +454,102 @@ func TestGetServerPreferredResources(t *testing.T) {
 		server.Close()
 	}
 }
+
+func TestGetServerPreferredResourcesRetries(t *testing.T) {
+	stable := unversioned.APIResourceList{
+		GroupVersion: "v1",
+		APIResources: []unversioned.APIResource{
+			{Name: "pods", Namespaced: true, Kind: "Pod"},
+		},
+	}
+	beta := unversioned.APIResourceList{
+		GroupVersion: "extensions/v1",
+		APIResources: []unversioned.APIResource{
+			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
+		},
+	}
+
+	response := func(numErrors int) http.HandlerFunc {
+		var i = 0
+		return func(w http.ResponseWriter, req *http.Request) {
+			var list interface{}
+			switch req.URL.Path {
+			case "/apis/extensions/v1beta1":
+				if i < numErrors {
+					i++
+					w.WriteHeader(http.StatusInternalServerError)
+					return
+				}
+				list = &beta
+			case "/api/v1":
+				list = &stable
+			case "/api":
+				list = &unversioned.APIVersions{
+					Versions: []string{
+						"v1",
+					},
+				}
+			case "/apis":
+				list = &unversioned.APIGroupList{
+					Groups: []unversioned.APIGroup{
+						{
+							Name: "extensions",
+							Versions: []unversioned.GroupVersionForDiscovery{
+								{GroupVersion: "extensions/v1beta1"},
+							},
+							PreferredVersion: unversioned.GroupVersionForDiscovery{
+								GroupVersion: "extensions/v1beta1",
+								Version:      "v1beta1",
+							},
+						},
+					},
+				}
+			default:
+				t.Logf("unexpected request: %s", req.URL.Path)
+				w.WriteHeader(http.StatusNotFound)
+				return
+			}
+			output, err := json.Marshal(list)
+			if err != nil {
+				t.Errorf("unexpected encoding error: %v", err)
+				return
+			}
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			w.Write(output)
+		}
+	}
+	tests := []struct {
+		responseErrors  int
+		expectResources int
+		expectedError   func(err error) bool
+	}{
+		{
+			responseErrors:  1,
+			expectResources: 2,
+			expectedError: func(err error) bool {
+				return err == nil
+			},
+		},
+		{
+			responseErrors:  2,
+			expectResources: 1,
+			expectedError:   IsGroupDiscoveryFailedError,
+		},
+	}
+
+	for i, tc := range tests {
+		server := httptest.NewServer(http.HandlerFunc(response(tc.responseErrors)))
+		defer server.Close()
+
+		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+		got, err := client.ServerPreferredResources()
+		if !tc.expectedError(err) {
+			t.Errorf("case %d: unexpected error: %v", i, err)
+		}
+		if len(got) != tc.expectResources {
+			t.Errorf("case %d: expect %d resources, got %#v", i, tc.expectResources, got)
+		}
+		server.Close()
+	}
+}

discovery/fake/discovery.go

@@ -18,10 +18,11 @@ package fake
 
 import (
 	"github.com/emicklei/go-restful/swagger"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/api/v1"
-	"k8s.io/client-go/1.4/pkg/version"
-	"k8s.io/client-go/1.4/testing"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/pkg/version"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/testing"
 )
 
 type FakeDiscovery struct {
@@ -80,3 +81,7 @@ func (c *FakeDiscovery) SwaggerSchema(version unversioned.GroupVersion) (*swagge
 	c.Invokes(action, nil)
 	return &swagger.ApiDeclaration{}, nil
 }
+
+func (c *FakeDiscovery) RESTClient() rest.Interface {
+	return nil
+}

discovery/helper.go

@@ -0,0 +1,109 @@
+/*
+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"
+
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/util/sets"
+	"k8s.io/client-go/pkg/version"
+	// Import solely to initialize client auth plugins.
+	_ "k8s.io/client-go/plugin/pkg/client/auth"
+)
+
+// MatchesServerVersion queries the server to compares the build version
+// (git hash) of the client with the server's build version. It returns an error
+// if it failed to contact the server or if the versions are not an exact match.
+func MatchesServerVersion(client DiscoveryInterface) error {
+	cVer := version.Get()
+	sVer, err := client.ServerVersion()
+	if err != nil {
+		return fmt.Errorf("couldn't read version from server: %v\n", err)
+	}
+	// GitVersion includes GitCommit and GitTreeState, but best to be safe?
+	if cVer.GitVersion != sVer.GitVersion || cVer.GitCommit != sVer.GitCommit || cVer.GitTreeState != sVer.GitTreeState {
+		return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", sVer, cVer)
+	}
+
+	return nil
+}
+
+// NegotiateVersion queries the server's supported api versions to find
+// a version that both client and server support.
+// - If no version is provided, try registered client versions in order of
+//   preference.
+// - If version is provided and the server does not support it,
+//   return an error.
+func NegotiateVersion(client DiscoveryInterface, requiredGV *unversioned.GroupVersion, clientRegisteredGVs []unversioned.GroupVersion) (*unversioned.GroupVersion, error) {
+	clientVersions := sets.String{}
+	for _, gv := range clientRegisteredGVs {
+		clientVersions.Insert(gv.String())
+	}
+	groups, err := client.ServerGroups()
+	if err != nil {
+		// This is almost always a connection error, and higher level code should treat this as a generic error,
+		// not a negotiation specific error.
+		return nil, err
+	}
+	versions := unversioned.ExtractGroupVersions(groups)
+	serverVersions := sets.String{}
+	for _, v := range versions {
+		serverVersions.Insert(v)
+	}
+
+	// If version explicitly requested verify that both client and server support it.
+	// If server does not support warn, but try to negotiate a lower version.
+	if requiredGV != nil {
+		if !clientVersions.Has(requiredGV.String()) {
+			return nil, fmt.Errorf("client does not support API version %q; client supported API versions: %v", requiredGV, clientVersions)
+
+		}
+		// If the server supports no versions, then we should just use the preferredGV
+		// This can happen because discovery fails due to 403 Forbidden errors
+		if len(serverVersions) == 0 {
+			return requiredGV, nil
+		}
+		if serverVersions.Has(requiredGV.String()) {
+			return requiredGV, nil
+		}
+		// If we are using an explicit config version the server does not support, fail.
+		return nil, fmt.Errorf("server does not support API version %q", requiredGV)
+	}
+
+	for _, clientGV := range clientRegisteredGVs {
+		if serverVersions.Has(clientGV.String()) {
+			// Version was not explicitly requested in command config (--api-version).
+			// Ok to fall back to a supported version with a warning.
+			// TODO: caesarxuchao: enable the warning message when we have
+			// proper fix. Please refer to issue #14895.
+			// if len(version) != 0 {
+			// 	glog.Warningf("Server does not support API version '%s'. Falling back to '%s'.", version, clientVersion)
+			// }
+			t := clientGV
+			return &t, nil
+		}
+	}
+
+	// if we have no server versions and we have no required version, choose the first clientRegisteredVersion
+	if len(serverVersions) == 0 && len(clientRegisteredGVs) > 0 {
+		return &clientRegisteredGVs[0], nil
+	}
+
+	return nil, fmt.Errorf("failed to negotiate an api version; server supports: %v, client supports: %v",
+		serverVersions, clientVersions)
+}

discovery/helper_blackbox_test.go

@@ -0,0 +1,156 @@
+/*
+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 discovery_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"testing"
+
+	"k8s.io/client-go/discovery"
+	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/api/testapi"
+	uapi "k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/apimachinery/registered"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/rest/fake"
+)
+
+func objBody(object interface{}) io.ReadCloser {
+	output, err := json.MarshalIndent(object, "", "")
+	if err != nil {
+		panic(err)
+	}
+	return ioutil.NopCloser(bytes.NewReader([]byte(output)))
+}
+
+func TestNegotiateVersion(t *testing.T) {
+	tests := []struct {
+		name            string
+		requiredVersion *uapi.GroupVersion
+		expectedVersion *uapi.GroupVersion
+		serverVersions  []string
+		clientVersions  []uapi.GroupVersion
+		expectErr       func(err error) bool
+		sendErr         error
+		statusCode      int
+	}{
+		{
+			name:            "server supports client default",
+			serverVersions:  []string{"version1", registered.GroupOrDie(api.GroupName).GroupVersion.String()},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "version1"},
+			statusCode:      http.StatusOK,
+		},
+		{
+			name:            "server falls back to client supported",
+			serverVersions:  []string{"version1"},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "version1"},
+			statusCode:      http.StatusOK,
+		},
+		{
+			name:            "explicit version supported",
+			requiredVersion: &uapi.GroupVersion{Version: "v1"},
+			serverVersions:  []string{"/version1", registered.GroupOrDie(api.GroupName).GroupVersion.String()},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "v1"},
+			statusCode:      http.StatusOK,
+		},
+		{
+			name:            "explicit version not supported on server",
+			requiredVersion: &uapi.GroupVersion{Version: "v1"},
+			serverVersions:  []string{"version1"},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectErr:       func(err error) bool { return strings.Contains(err.Error(), `server does not support API version "v1"`) },
+			statusCode:      http.StatusOK,
+		},
+		{
+			name:            "explicit version not supported on client",
+			requiredVersion: &uapi.GroupVersion{Version: "v1"},
+			serverVersions:  []string{"v1"},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}},
+			expectErr:       func(err error) bool { return strings.Contains(err.Error(), `client does not support API version "v1"`) },
+			statusCode:      http.StatusOK,
+		},
+		{
+			name:           "connection refused error",
+			serverVersions: []string{"version1"},
+			clientVersions: []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			sendErr:        errors.New("connection refused"),
+			expectErr:      func(err error) bool { return strings.Contains(err.Error(), "connection refused") },
+			statusCode:     http.StatusOK,
+		},
+		{
+			name:            "discovery fails due to 403 Forbidden errors and thus serverVersions is empty, use default GroupVersion",
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "version1"},
+			statusCode:      http.StatusForbidden,
+		},
+		{
+			name:            "discovery fails due to 404 Not Found errors and thus serverVersions is empty, use requested GroupVersion",
+			requiredVersion: &uapi.GroupVersion{Version: "version1"},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "version1"},
+			statusCode:      http.StatusNotFound,
+		},
+		{
+			name:       "discovery fails due to 403 Forbidden errors and thus serverVersions is empty, no fallback GroupVersion",
+			expectErr:  func(err error) bool { return strings.Contains(err.Error(), "failed to negotiate an api version;") },
+			statusCode: http.StatusForbidden,
+		},
+	}
+
+	for _, test := range tests {
+		fakeClient := &fake.RESTClient{
+			NegotiatedSerializer: testapi.Default.NegotiatedSerializer(),
+			Resp: &http.Response{
+				StatusCode: test.statusCode,
+				Body:       objBody(&uapi.APIVersions{Versions: test.serverVersions}),
+			},
+			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+				if test.sendErr != nil {
+					return nil, test.sendErr
+				}
+				header := http.Header{}
+				header.Set("Content-Type", runtime.ContentTypeJSON)
+				return &http.Response{StatusCode: test.statusCode, Header: header, Body: objBody(&uapi.APIVersions{Versions: test.serverVersions})}, nil
+			}),
+		}
+		c := discovery.NewDiscoveryClientForConfigOrDie(&rest.Config{})
+		c.RESTClient().(*rest.RESTClient).Client = fakeClient.Client
+		response, err := discovery.NegotiateVersion(c, test.requiredVersion, test.clientVersions)
+		if err == nil && test.expectErr != nil {
+			t.Errorf("expected error, got nil for [%s].", test.name)
+		}
+		if err != nil {
+			if test.expectErr == nil || !test.expectErr(err) {
+				t.Errorf("unexpected error for [%s]: %v.", test.name, err)
+			}
+			continue
+		}
+		if *response != *test.expectedVersion {
+			t.Errorf("%s: expected version %s, got %s.", test.name, test.expectedVersion, response)
+		}
+	}
+}

discovery/restmapper.go

@@ -17,11 +17,14 @@ limitations under the License.
 package discovery
 
 import (
+	"fmt"
 	"sync"
 
-	"k8s.io/client-go/1.4/pkg/api/errors"
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/api/errors"
+	"k8s.io/client-go/pkg/api/meta"
+	"k8s.io/client-go/pkg/api/unversioned"
+
+	"github.com/golang/glog"
 )
 
 // APIGroupResources is an API group with a mapping of versions to
@@ -34,7 +37,7 @@ type APIGroupResources struct {
 }
 
 // NewRESTMapper returns a PriorityRESTMapper based on the discovered
-// groups and resourced passed in.
+// groups and resources passed in.
 func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.VersionInterfacesFunc) meta.RESTMapper {
 	unionMapper := meta.MultiRESTMapper{}
 
@@ -46,8 +49,8 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 		groupPriority = append(groupPriority, group.Group.Name)
 
 		if len(group.Group.PreferredVersion.Version) != 0 {
-			preffered := group.Group.PreferredVersion.Version
-			if _, ok := group.VersionedResources[preffered]; ok {
+			preferred := group.Group.PreferredVersion.Version
+			if _, ok := group.VersionedResources[preferred]; ok {
 				resourcePriority = append(resourcePriority, unversioned.GroupVersionResource{
 					Group:    group.Group.Name,
 					Version:  group.Group.PreferredVersion.Version,
@@ -140,14 +143,14 @@ func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
 type DeferredDiscoveryRESTMapper struct {
 	initMu           sync.Mutex
 	delegate         meta.RESTMapper
-	cl               DiscoveryInterface
+	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 DiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
+func NewDeferredDiscoveryRESTMapper(cl CachedDiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
 	return &DeferredDiscoveryRESTMapper{
 		cl:               cl,
 		versionInterface: versionInterface,
@@ -174,79 +177,118 @@ func (d *DeferredDiscoveryRESTMapper) getDelegate() (meta.RESTMapper, error) {
 // 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
-	d.initMu.Unlock()
 }
 
 // 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 unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error) {
+func (d *DeferredDiscoveryRESTMapper) KindFor(resource unversioned.GroupVersionResource) (gvk unversioned.GroupVersionKind, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return unversioned.GroupVersionKind{}, err
 	}
-	return del.KindFor(resource)
+	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 unversioned.GroupVersionResource) ([]unversioned.GroupVersionKind, error) {
+func (d *DeferredDiscoveryRESTMapper) KindsFor(resource unversioned.GroupVersionResource) (gvks []unversioned.GroupVersionKind, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	return del.KindsFor(resource)
+	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 unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error) {
+func (d *DeferredDiscoveryRESTMapper) ResourceFor(input unversioned.GroupVersionResource) (gvr unversioned.GroupVersionResource, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return unversioned.GroupVersionResource{}, err
 	}
-	return del.ResourceFor(input)
+	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 unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
+func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input unversioned.GroupVersionResource) (gvrs []unversioned.GroupVersionResource, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	return del.ResourcesFor(input)
+	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 unversioned.GroupKind, versions ...string) (*meta.RESTMapping, error) {
+func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (m *meta.RESTMapping, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	return del.RESTMapping(gk, versions...)
+	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 unversioned.GroupKind) ([]*meta.RESTMapping, error) {
+func (d *DeferredDiscoveryRESTMapper) RESTMappings(gk unversioned.GroupKind) (ms []*meta.RESTMapping, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	return del.RESTMappings(gk)
+	ms, err = del.RESTMappings(gk)
+	if len(ms) == 0 && !d.cl.Fresh() {
+		d.Reset()
+		ms, err = d.RESTMappings(gk)
+	}
+	return
 }
 
 // AliasesForResource returns whether a resource has an alias or not.
-func (d *DeferredDiscoveryRESTMapper) AliasesForResource(resource string) ([]string, bool) {
+func (d *DeferredDiscoveryRESTMapper) AliasesForResource(resource string) (as []string, ok bool) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, false
 	}
-	return del.AliasesForResource(resource)
+	as, ok = del.AliasesForResource(resource)
+	if len(as) == 0 && !d.cl.Fresh() {
+		d.Reset()
+		as, ok = d.AliasesForResource(resource)
+	}
+	return
 }
 
 // ResourceSingularizer converts a resource name from plural to
@@ -256,7 +298,20 @@ func (d *DeferredDiscoveryRESTMapper) ResourceSingularizer(resource string) (sin
 	if err != nil {
 		return resource, err
 	}
-	return del.ResourceSingularizer(resource)
+	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

discovery/restmapper_test.go

@@ -0,0 +1,325 @@
+/*
+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 (
+	"reflect"
+	"testing"
+
+	"k8s.io/client-go/pkg/api/errors"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/apimachinery/registered"
+	"k8s.io/client-go/pkg/version"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/rest/fake"
+
+	"github.com/emicklei/go-restful/swagger"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRESTMapper(t *testing.T) {
+	resources := []*APIGroupResources{
+		{
+			Group: unversioned.APIGroup{
+				Versions: []unversioned.GroupVersionForDiscovery{
+					{Version: "v1"},
+					{Version: "v2"},
+				},
+				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1"},
+			},
+			VersionedResources: map[string][]unversioned.APIResource{
+				"v1": {
+					{Name: "pods", Namespaced: true, Kind: "Pod"},
+				},
+				"v2": {
+					{Name: "pods", Namespaced: true, Kind: "Pod"},
+				},
+			},
+		},
+		{
+			Group: unversioned.APIGroup{
+				Name: "extensions",
+				Versions: []unversioned.GroupVersionForDiscovery{
+					{Version: "v1beta"},
+				},
+				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1beta"},
+			},
+			VersionedResources: map[string][]unversioned.APIResource{
+				"v1beta": {
+					{Name: "jobs", Namespaced: true, Kind: "Job"},
+				},
+			},
+		},
+	}
+
+	restMapper := NewRESTMapper(resources, nil)
+
+	kindTCs := []struct {
+		input unversioned.GroupVersionResource
+		want  unversioned.GroupVersionKind
+	}{
+		{
+			input: unversioned.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionKind{
+				Version: "v1",
+				Kind:    "Pod",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Version:  "v2",
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionKind{
+				Version: "v2",
+				Kind:    "Pod",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionKind{
+				Version: "v1",
+				Kind:    "Pod",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Resource: "jobs",
+			},
+			want: unversioned.GroupVersionKind{
+				Group:   "extensions",
+				Version: "v1beta",
+				Kind:    "Job",
+			},
+		},
+	}
+
+	for _, tc := range kindTCs {
+		got, err := restMapper.KindFor(tc.input)
+		if err != nil {
+			t.Errorf("KindFor(%#v) unexpected error: %v", tc.input, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("KindFor(%#v) = %#v, want %#v", tc.input, got, tc.want)
+		}
+	}
+
+	resourceTCs := []struct {
+		input unversioned.GroupVersionResource
+		want  unversioned.GroupVersionResource
+	}{
+		{
+			input: unversioned.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Version:  "v2",
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionResource{
+				Version:  "v2",
+				Resource: "pods",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Resource: "jobs",
+			},
+			want: unversioned.GroupVersionResource{
+				Group:    "extensions",
+				Version:  "v1beta",
+				Resource: "jobs",
+			},
+		},
+	}
+
+	for _, tc := range resourceTCs {
+		got, err := restMapper.ResourceFor(tc.input)
+		if err != nil {
+			t.Errorf("ResourceFor(%#v) unexpected error: %v", tc.input, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("ResourceFor(%#v) = %#v, want %#v", tc.input, got, tc.want)
+		}
+	}
+}
+
+func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
+	assert := assert.New(t)
+
+	cdc := fakeCachedDiscoveryInterface{fresh: false}
+	m := NewDeferredDiscoveryRESTMapper(&cdc, registered.InterfacesFor)
+	assert.False(cdc.fresh, "should NOT be fresh after instantiation")
+	assert.Zero(cdc.invalidateCalls, "should not have called Invalidate()")
+
+	gvk, err := m.KindFor(unversioned.GroupVersionResource{
+		Group:    "a",
+		Version:  "v1",
+		Resource: "foo",
+	})
+	assert.NoError(err)
+	assert.True(cdc.fresh, "should be fresh after a cache-miss")
+	assert.Equal(cdc.invalidateCalls, 1, "should have called Invalidate() once")
+	assert.Equal(gvk.Kind, "Foo")
+
+	gvk, err = m.KindFor(unversioned.GroupVersionResource{
+		Group:    "a",
+		Version:  "v1",
+		Resource: "foo",
+	})
+	assert.NoError(err)
+	assert.Equal(cdc.invalidateCalls, 1, "should NOT have called Invalidate() again")
+
+	gvk, err = m.KindFor(unversioned.GroupVersionResource{
+		Group:    "a",
+		Version:  "v1",
+		Resource: "bar",
+	})
+	assert.Error(err)
+	assert.Equal(cdc.invalidateCalls, 1, "should NOT have called Invalidate() again after another cache-miss, but with fresh==true")
+
+	cdc.fresh = false
+	gvk, err = m.KindFor(unversioned.GroupVersionResource{
+		Group:    "a",
+		Version:  "v1",
+		Resource: "bar",
+	})
+	assert.Error(err)
+	assert.Equal(cdc.invalidateCalls, 2, "should HAVE called Invalidate() again after another cache-miss, but with fresh==false")
+}
+
+type fakeCachedDiscoveryInterface struct {
+	invalidateCalls int
+	fresh           bool
+	enabledA        bool
+}
+
+var _ CachedDiscoveryInterface = &fakeCachedDiscoveryInterface{}
+
+func (c *fakeCachedDiscoveryInterface) Fresh() bool {
+	return c.fresh
+}
+
+func (c *fakeCachedDiscoveryInterface) Invalidate() {
+	c.invalidateCalls = c.invalidateCalls + 1
+	c.fresh = true
+	c.enabledA = true
+}
+
+func (c *fakeCachedDiscoveryInterface) RESTClient() rest.Interface {
+	return &fake.RESTClient{}
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerGroups() (*unversioned.APIGroupList, error) {
+	if c.enabledA {
+		return &unversioned.APIGroupList{
+			Groups: []unversioned.APIGroup{
+				{
+					Name: "a",
+					Versions: []unversioned.GroupVersionForDiscovery{
+						{
+							GroupVersion: "a/v1",
+							Version:      "v1",
+						},
+					},
+					PreferredVersion: unversioned.GroupVersionForDiscovery{
+						GroupVersion: "a/v1",
+						Version:      "v1",
+					},
+				},
+			},
+		}, nil
+	}
+	return &unversioned.APIGroupList{}, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerResourcesForGroupVersion(groupVersion string) (*unversioned.APIResourceList, error) {
+	if c.enabledA && groupVersion == "a/v1" {
+		return &unversioned.APIResourceList{
+			GroupVersion: "a/v1",
+			APIResources: []unversioned.APIResource{
+				{
+					Name:       "foo",
+					Kind:       "Foo",
+					Namespaced: false,
+				},
+			},
+		}, nil
+	}
+
+	return nil, errors.NewNotFound(unversioned.GroupResource{}, "")
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerResources() (map[string]*unversioned.APIResourceList, error) {
+	if c.enabledA {
+		av1, _ := c.ServerResourcesForGroupVersion("a/v1")
+		return map[string]*unversioned.APIResourceList{
+			"a/v1": av1,
+		}, nil
+	}
+	return map[string]*unversioned.APIResourceList{}, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerPreferredResources() ([]unversioned.GroupVersionResource, error) {
+	if c.enabledA {
+		return []unversioned.GroupVersionResource{
+			{
+				Group:    "a",
+				Version:  "v1",
+				Resource: "foo",
+			},
+		}, nil
+	}
+	return []unversioned.GroupVersionResource{}, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error) {
+	return []unversioned.GroupVersionResource{}, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerVersion() (*version.Info, error) {
+	return &version.Info{}, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error) {
+	return &swagger.ApiDeclaration{}, nil
+}

discovery/unstructured.go

@@ -19,8 +19,8 @@ package discovery
 import (
 	"fmt"
 
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/runtime"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/runtime"
 )
 
 // UnstructuredObjectTyper provides a runtime.ObjectTyper implmentation for

dynamic/client.go

@@ -26,15 +26,15 @@ import (
 	"net/url"
 	"strings"
 
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/api/v1"
-	"k8s.io/client-go/1.4/pkg/conversion/queryparams"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/runtime/serializer"
-	"k8s.io/client-go/1.4/pkg/util/flowcontrol"
-	"k8s.io/client-go/1.4/pkg/watch"
-	"k8s.io/client-go/1.4/rest"
+	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/pkg/conversion/queryparams"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/pkg/runtime/serializer"
+	"k8s.io/client-go/pkg/util/flowcontrol"
+	"k8s.io/client-go/pkg/watch"
+	"k8s.io/client-go/rest"
 )
 
 // Client is a Kubernetes client that allows you to access metadata
@@ -241,13 +241,22 @@ func (dynamicCodec) Encode(obj runtime.Object, w io.Writer) error {
 
 // ContentConfig returns a rest.ContentConfig for dynamic types.
 func ContentConfig() rest.ContentConfig {
-	// TODO: it's questionable that this should be using anything other than unstructured schema and JSON
-	codec := dynamicCodec{}
-	streamingInfo, _ := api.Codecs.StreamingSerializerForMediaType("application/json;stream=watch", nil)
+	var jsonInfo runtime.SerializerInfo
+	// TODO: api.Codecs here should become "pkg/apis/server/scheme" which is the minimal core you need
+	// to talk to a kubernetes server
+	for _, info := range api.Codecs.SupportedMediaTypes() {
+		if info.MediaType == runtime.ContentTypeJSON {
+			jsonInfo = info
+			break
+		}
+	}
+
+	jsonInfo.Serializer = dynamicCodec{}
+	jsonInfo.PrettySerializer = nil
 	return rest.ContentConfig{
 		AcceptContentTypes:   runtime.ContentTypeJSON,
 		ContentType:          runtime.ContentTypeJSON,
-		NegotiatedSerializer: serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec}, streamingInfo),
+		NegotiatedSerializer: serializer.NegotiatedSerializerWrapper(jsonInfo),
 	}
 }
 

dynamic/client_pool.go

@@ -0,0 +1,115 @@
+/*
+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 dynamic
+
+import (
+	"sync"
+
+	"k8s.io/client-go/pkg/api/meta"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/rest"
+)
+
+// ClientPool manages a pool of dynamic clients.
+type ClientPool interface {
+	// ClientForGroupVersionKind returns a client configured for the specified groupVersionResource.
+	// Resource may be empty.
+	ClientForGroupVersionResource(resource unversioned.GroupVersionResource) (*Client, error)
+	// ClientForGroupVersionKind returns a client configured for the specified groupVersionKind.
+	// Kind may be empty.
+	ClientForGroupVersionKind(kind unversioned.GroupVersionKind) (*Client, error)
+}
+
+// APIPathResolverFunc knows how to convert a groupVersion to its API path. The Kind field is
+// optional.
+type APIPathResolverFunc func(kind unversioned.GroupVersionKind) string
+
+// LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
+func LegacyAPIPathResolverFunc(kind unversioned.GroupVersionKind) string {
+	if len(kind.Group) == 0 {
+		return "/api"
+	}
+	return "/apis"
+}
+
+// clientPoolImpl implements ClientPool and caches clients for the resource group versions
+// is asked to retrieve. This type is thread safe.
+type clientPoolImpl struct {
+	lock                sync.RWMutex
+	config              *rest.Config
+	clients             map[unversioned.GroupVersion]*Client
+	apiPathResolverFunc APIPathResolverFunc
+	mapper              meta.RESTMapper
+}
+
+// NewClientPool returns a ClientPool from the specified config. It reuses clients for the the same
+// group version. It is expected this type may be wrapped by specific logic that special cases certain
+// resources or groups.
+func NewClientPool(config *rest.Config, mapper meta.RESTMapper, apiPathResolverFunc APIPathResolverFunc) ClientPool {
+	confCopy := *config
+
+	return &clientPoolImpl{
+		config:              &confCopy,
+		clients:             map[unversioned.GroupVersion]*Client{},
+		apiPathResolverFunc: apiPathResolverFunc,
+		mapper:              mapper,
+	}
+}
+
+// ClientForGroupVersionResource uses the provided RESTMapper to identify the appropriate resource. Resource may
+// be empty. If no matching kind is found the underlying client for that group is still returned.
+func (c *clientPoolImpl) ClientForGroupVersionResource(resource unversioned.GroupVersionResource) (*Client, error) {
+	kinds, err := c.mapper.KindsFor(resource)
+	if err != nil {
+		if meta.IsNoMatchError(err) {
+			return c.ClientForGroupVersionKind(unversioned.GroupVersionKind{Group: resource.Group, Version: resource.Version})
+		}
+		return nil, err
+	}
+	return c.ClientForGroupVersionKind(kinds[0])
+}
+
+// ClientForGroupVersion returns a client for the specified groupVersion, creates one if none exists. Kind
+// in the GroupVersionKind may be empty.
+func (c *clientPoolImpl) ClientForGroupVersionKind(kind unversioned.GroupVersionKind) (*Client, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	gv := kind.GroupVersion()
+
+	// do we have a client already configured?
+	if existingClient, found := c.clients[gv]; found {
+		return existingClient, nil
+	}
+
+	// avoid changing the original config
+	confCopy := *c.config
+	conf := &confCopy
+
+	// we need to set the api path based on group version, if no group, default to legacy path
+	conf.APIPath = c.apiPathResolverFunc(kind)
+
+	// we need to make a client
+	conf.GroupVersion = &gv
+
+	dynamicClient, err := NewClient(conf)
+	if err != nil {
+		return nil, err
+	}
+	c.clients[gv] = dynamicClient
+	return dynamicClient, nil
+}

dynamic/client_test.go

@@ -25,14 +25,14 @@ import (
 	"reflect"
 	"testing"
 
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/api/v1"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/runtime/serializer/streaming"
-	"k8s.io/client-go/1.4/pkg/watch"
-	"k8s.io/client-go/1.4/pkg/watch/versioned"
-	"k8s.io/client-go/1.4/rest"
+	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/pkg/runtime/serializer/streaming"
+	"k8s.io/client-go/pkg/watch"
+	"k8s.io/client-go/pkg/watch/versioned"
+	"k8s.io/client-go/rest"
 )
 
 func getJSON(version, kind, name string) []byte {
@@ -529,6 +529,7 @@ func TestPatch(t *testing.T) {
 				return
 			}
 
+			w.Header().Set("Content-Type", "application/json")
 			w.Write(data)
 		})
 		if err != nil {

dynamic/dynamic_util.go

@@ -19,9 +19,9 @@ package dynamic
 import (
 	"fmt"
 
-	"k8s.io/client-go/1.4/pkg/api/meta"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/runtime"
+	"k8s.io/client-go/pkg/api/meta"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/runtime"
 )
 
 // VersionInterfaces provides an object converter and metadata