Update godeps

vendor/k8s.io/kubernetes/pkg/client/cache/delta_fifo.go

@@ -522,6 +522,18 @@ func (f *DeltaFIFO) syncKey(key string) error {
 		return nil
 	}
 
+	// If we are doing Resync() and there is already an event queued for that object,
+	// we ignore the Resync for it. This is to avoid the race, in which the resync
+	// comes with the previous value of object (since queueing an event for the object
+	// doesn't trigger changing the underlying store <knownObjects>.
+	id, err := f.KeyOf(obj)
+	if err != nil {
+		return KeyError{obj, err}
+	}
+	if len(f.items[id]) > 0 {
+		return nil
+	}
+
 	if err := f.queueActionLocked(Sync, obj); err != nil {
 		return fmt.Errorf("couldn't queue object: %v", err)
 	}

vendor/k8s.io/kubernetes/pkg/client/cache/listers.go

@@ -285,12 +285,12 @@ func (s *StoreToReplicationControllerLister) GetPodControllers(pod *api.Pod) (co
 
 // StoreToDeploymentLister gives a store List and Exists methods. The store must contain only Deployments.
 type StoreToDeploymentLister struct {
-	Store
+	Indexer
 }
 
 // Exists checks if the given deployment exists in the store.
 func (s *StoreToDeploymentLister) Exists(deployment *extensions.Deployment) (bool, error) {
-	_, exists, err := s.Store.Get(deployment)
+	_, exists, err := s.Indexer.Get(deployment)
 	if err != nil {
 		return false, err
 	}
@@ -300,7 +300,7 @@ func (s *StoreToDeploymentLister) Exists(deployment *extensions.Deployment) (boo
 // 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.Store.List() {
+	for _, c := range s.Indexer.List() {
 		deployments = append(deployments, *(c.(*extensions.Deployment)))
 	}
 	return deployments, nil
@@ -308,20 +308,17 @@ func (s *StoreToDeploymentLister) List() (deployments []extensions.Deployment, e
 
 // 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) {
-	var d extensions.Deployment
-
 	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
-	for _, m := range s.Store.List() {
-		d = *m.(*extensions.Deployment)
-		if d.Namespace != rs.Namespace {
-			continue
-		}
-
+	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)
@@ -338,6 +335,81 @@ func (s *StoreToDeploymentLister) GetDeploymentsForReplicaSet(rs *extensions.Rep
 	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

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset.go

@@ -26,6 +26,7 @@ import (
 	unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
 	unversionedextensions "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned"
 	unversionedrbac "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned"
+	unversionedstorage "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/storage/unversioned"
 	restclient "k8s.io/kubernetes/pkg/client/restclient"
 	discovery "k8s.io/kubernetes/pkg/client/typed/discovery"
 	"k8s.io/kubernetes/pkg/util/flowcontrol"
@@ -41,6 +42,7 @@ type Interface interface {
 	Certificates() unversionedcertificates.CertificatesInterface
 	Extensions() unversionedextensions.ExtensionsInterface
 	Rbac() unversionedrbac.RbacInterface
+	Storage() unversionedstorage.StorageInterface
 }
 
 // Clientset contains the clients for groups. Each group has exactly one
@@ -55,6 +57,7 @@ type Clientset struct {
 	*unversionedcertificates.CertificatesClient
 	*unversionedextensions.ExtensionsClient
 	*unversionedrbac.RbacClient
+	*unversionedstorage.StorageClient
 }
 
 // Core retrieves the CoreClient
@@ -121,6 +124,14 @@ func (c *Clientset) Rbac() unversionedrbac.RbacInterface {
 	return c.RbacClient
 }
 
+// Storage retrieves the StorageClient
+func (c *Clientset) Storage() unversionedstorage.StorageInterface {
+	if c == nil {
+		return nil
+	}
+	return c.StorageClient
+}
+
 // Discovery retrieves the DiscoveryClient
 func (c *Clientset) Discovery() discovery.DiscoveryInterface {
 	return c.DiscoveryClient
@@ -166,6 +177,10 @@ func NewForConfig(c *restclient.Config) (*Clientset, error) {
 	if err != nil {
 		return nil, err
 	}
+	clientset.StorageClient, err = unversionedstorage.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
 
 	clientset.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
 	if err != nil {
@@ -187,6 +202,7 @@ func NewForConfigOrDie(c *restclient.Config) *Clientset {
 	clientset.CertificatesClient = unversionedcertificates.NewForConfigOrDie(c)
 	clientset.ExtensionsClient = unversionedextensions.NewForConfigOrDie(c)
 	clientset.RbacClient = unversionedrbac.NewForConfigOrDie(c)
+	clientset.StorageClient = unversionedstorage.NewForConfigOrDie(c)
 
 	clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &clientset
@@ -203,6 +219,7 @@ func New(c *restclient.RESTClient) *Clientset {
 	clientset.CertificatesClient = unversionedcertificates.New(c)
 	clientset.ExtensionsClient = unversionedextensions.New(c)
 	clientset.RbacClient = unversionedrbac.New(c)
+	clientset.StorageClient = unversionedstorage.New(c)
 
 	clientset.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &clientset

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/import_known_versions.go

@@ -32,6 +32,7 @@ import (
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
 	_ "k8s.io/kubernetes/pkg/apis/policy/install"
 	_ "k8s.io/kubernetes/pkg/apis/rbac/install"
+	_ "k8s.io/kubernetes/pkg/apis/storage/install"
 )
 
 func init() {

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/authentication/unversioned/generated_expansion.go

@@ -15,21 +15,3 @@ limitations under the License.
 */
 
 package unversioned
-
-import (
-	authenticationapi "k8s.io/kubernetes/pkg/apis/authentication"
-)
-
-type TokenReviewExpansion interface {
-	Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error)
-}
-
-func (c *tokenReviews) Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
-	result = &authenticationapi.TokenReview{}
-	err = c.client.Post().
-		Resource("tokenreviews").
-		Body(tokenReview).
-		Do().
-		Into(result)
-	return
-}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/authentication/unversioned/tokenreview_expansion.go

@@ -0,0 +1,35 @@
+/*
+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 unversioned
+
+import (
+	authenticationapi "k8s.io/kubernetes/pkg/apis/authentication"
+)
+
+type TokenReviewExpansion interface {
+	Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error)
+}
+
+func (c *tokenReviews) Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
+	result = &authenticationapi.TokenReview{}
+	err = c.client.Post().
+		Resource("tokenreviews").
+		Body(tokenReview).
+		Do().
+		Into(result)
+	return
+}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/authorization/unversioned/generated_expansion.go

@@ -15,22 +15,3 @@ limitations under the License.
 */
 
 package unversioned
-
-import (
-	authorizationapi "k8s.io/kubernetes/pkg/apis/authorization"
-)
-
-// The PodExpansion interface allows manually adding extra methods to the PodInterface.
-type SubjectAccessReviewExpansion interface {
-	Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error)
-}
-
-func (c *subjectAccessReviews) Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
-	result = &authorizationapi.SubjectAccessReview{}
-	err = c.client.Post().
-		Resource("subjectaccessreviews").
-		Body(sar).
-		Do().
-		Into(result)
-	return
-}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/authorization/unversioned/subjectaccessreview_expansion.go

@@ -0,0 +1,36 @@
+/*
+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 unversioned
+
+import (
+	authorizationapi "k8s.io/kubernetes/pkg/apis/authorization"
+)
+
+// The PodExpansion interface allows manually adding extra methods to the PodInterface.
+type SubjectAccessReviewExpansion interface {
+	Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error)
+}
+
+func (c *subjectAccessReviews) Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
+	result = &authorizationapi.SubjectAccessReview{}
+	err = c.client.Post().
+		Resource("subjectaccessreviews").
+		Body(sar).
+		Do().
+		Into(result)
+	return
+}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/certificates/unversioned/certificates_client.go

@@ -66,7 +66,7 @@ func New(c *restclient.RESTClient) *CertificatesClient {
 
 func setConfigDefaults(config *restclient.Config) error {
 	// if certificates group is not registered, return an error
-	g, err := registered.Group("certificates")
+	g, err := registered.Group("certificates.k8s.io")
 	if err != nil {
 		return err
 	}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/generated_expansion.go

@@ -18,6 +18,8 @@ package unversioned
 
 type ComponentStatusExpansion interface{}
 
+type ConfigMapExpansion interface{}
+
 type EndpointsExpansion interface{}
 
 type LimitRangeExpansion interface{}
@@ -35,5 +37,3 @@ type ResourceQuotaExpansion interface{}
 type SecretExpansion interface{}
 
 type ServiceAccountExpansion interface{}
-
-type ConfigMapExpansion interface{}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/extensions_client.go

@@ -30,7 +30,6 @@ type ExtensionsInterface interface {
 	PodSecurityPoliciesGetter
 	ReplicaSetsGetter
 	ScalesGetter
-	StorageClassesGetter
 	ThirdPartyResourcesGetter
 }
 
@@ -63,10 +62,6 @@ func (c *ExtensionsClient) Scales(namespace string) ScaleInterface {
 	return newScales(c, namespace)
 }
 
-func (c *ExtensionsClient) StorageClasses() StorageClassInterface {
-	return newStorageClasses(c)
-}
-
 func (c *ExtensionsClient) ThirdPartyResources() ThirdPartyResourceInterface {
 	return newThirdPartyResources(c)
 }

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/generated_expansion.go

@@ -18,16 +18,10 @@ package unversioned
 
 type DaemonSetExpansion interface{}
 
-type HorizontalPodAutoscalerExpansion interface{}
-
 type IngressExpansion interface{}
 
-type JobExpansion interface{}
-
 type PodSecurityPolicyExpansion interface{}
 
-type ThirdPartyResourceExpansion interface{}
-
 type ReplicaSetExpansion interface{}
 
-type StorageClassExpansion interface{}
+type ThirdPartyResourceExpansion interface{}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/job.go

@@ -1,150 +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 unversioned
-
-import (
-	api "k8s.io/kubernetes/pkg/api"
-	batch "k8s.io/kubernetes/pkg/apis/batch"
-	watch "k8s.io/kubernetes/pkg/watch"
-)
-
-// JobsGetter has a method to return a JobInterface.
-// A group's client should implement this interface.
-type JobsGetter interface {
-	Jobs(namespace string) JobInterface
-}
-
-// JobInterface has methods to work with Job resources.
-type JobInterface interface {
-	Create(*batch.Job) (*batch.Job, error)
-	Update(*batch.Job) (*batch.Job, error)
-	UpdateStatus(*batch.Job) (*batch.Job, error)
-	Delete(name string, options *api.DeleteOptions) error
-	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
-	Get(name string) (*batch.Job, error)
-	List(opts api.ListOptions) (*batch.JobList, error)
-	Watch(opts api.ListOptions) (watch.Interface, error)
-	JobExpansion
-}
-
-// jobs implements JobInterface
-type jobs struct {
-	client *ExtensionsClient
-	ns     string
-}
-
-// newJobs returns a Jobs
-func newJobs(c *ExtensionsClient, namespace string) *jobs {
-	return &jobs{
-		client: c,
-		ns:     namespace,
-	}
-}
-
-// Create takes the representation of a job and creates it.  Returns the server's representation of the job, and an error, if there is any.
-func (c *jobs) Create(job *batch.Job) (result *batch.Job, err error) {
-	result = &batch.Job{}
-	err = c.client.Post().
-		Namespace(c.ns).
-		Resource("jobs").
-		Body(job).
-		Do().
-		Into(result)
-	return
-}
-
-// Update takes the representation of a job and updates it. Returns the server's representation of the job, and an error, if there is any.
-func (c *jobs) Update(job *batch.Job) (result *batch.Job, err error) {
-	result = &batch.Job{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("jobs").
-		Name(job.Name).
-		Body(job).
-		Do().
-		Into(result)
-	return
-}
-
-func (c *jobs) UpdateStatus(job *batch.Job) (result *batch.Job, err error) {
-	result = &batch.Job{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("jobs").
-		Name(job.Name).
-		SubResource("status").
-		Body(job).
-		Do().
-		Into(result)
-	return
-}
-
-// Delete takes name of the job and deletes it. Returns an error if one occurs.
-func (c *jobs) Delete(name string, options *api.DeleteOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("jobs").
-		Name(name).
-		Body(options).
-		Do().
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *jobs) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("jobs").
-		VersionedParams(&listOptions, api.ParameterCodec).
-		Body(options).
-		Do().
-		Error()
-}
-
-// Get takes name of the job, and returns the corresponding job object, and an error if there is any.
-func (c *jobs) Get(name string) (result *batch.Job, err error) {
-	result = &batch.Job{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("jobs").
-		Name(name).
-		Do().
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of Jobs that match those selectors.
-func (c *jobs) List(opts api.ListOptions) (result *batch.JobList, err error) {
-	result = &batch.JobList{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("jobs").
-		VersionedParams(&opts, api.ParameterCodec).
-		Do().
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested jobs.
-func (c *jobs) Watch(opts api.ListOptions) (watch.Interface, error) {
-	return c.client.Get().
-		Prefix("watch").
-		Namespace(c.ns).
-		Resource("jobs").
-		VersionedParams(&opts, api.ParameterCodec).
-		Watch()
-}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/storage/unversioned/doc.go

@@ -0,0 +1,20 @@
+/*
+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 the default arguments.
+
+// This package has the automatically generated typed clients.
+package unversioned

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/storage/unversioned/generated_expansion.go

@@ -0,0 +1,19 @@
+/*
+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 unversioned
+
+type StorageClassExpansion interface{}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/storage/unversioned/storage_client.go

@@ -0,0 +1,101 @@
+/*
+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 unversioned
+
+import (
+	api "k8s.io/kubernetes/pkg/api"
+	registered "k8s.io/kubernetes/pkg/apimachinery/registered"
+	restclient "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+type StorageInterface interface {
+	GetRESTClient() *restclient.RESTClient
+	StorageClassesGetter
+}
+
+// StorageClient is used to interact with features provided by the Storage group.
+type StorageClient struct {
+	*restclient.RESTClient
+}
+
+func (c *StorageClient) StorageClasses() StorageClassInterface {
+	return newStorageClasses(c)
+}
+
+// NewForConfig creates a new StorageClient for the given config.
+func NewForConfig(c *restclient.Config) (*StorageClient, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := restclient.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 *restclient.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 *restclient.RESTClient) *StorageClient {
+	return &StorageClient{c}
+}
+
+func setConfigDefaults(config *restclient.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 = restclient.DefaultKubernetesUserAgent()
+	}
+	// TODO: Unconditionally set the config.Version, until we fix the config.
+	//if config.Version == "" {
+	copyGroupVersion := g.GroupVersion
+	config.GroupVersion = &copyGroupVersion
+	//}
+
+	config.NegotiatedSerializer = api.Codecs
+
+	if config.QPS == 0 {
+		config.QPS = 5
+	}
+	if config.Burst == 0 {
+		config.Burst = 10
+	}
+	return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *StorageClient) GetRESTClient() *restclient.RESTClient {
+	if c == nil {
+		return nil
+	}
+	return c.RESTClient
+}

vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/storage/unversioned/storageclass.go

@@ -18,7 +18,7 @@ package unversioned
 
 import (
 	api "k8s.io/kubernetes/pkg/api"
-	extensions "k8s.io/kubernetes/pkg/apis/extensions"
+	storage "k8s.io/kubernetes/pkg/apis/storage"
 	watch "k8s.io/kubernetes/pkg/watch"
 )
 
@@ -30,32 +30,32 @@ type StorageClassesGetter interface {
 
 // StorageClassInterface has methods to work with StorageClass resources.
 type StorageClassInterface interface {
-	Create(*extensions.StorageClass) (*extensions.StorageClass, error)
-	Update(*extensions.StorageClass) (*extensions.StorageClass, error)
+	Create(*storage.StorageClass) (*storage.StorageClass, error)
+	Update(*storage.StorageClass) (*storage.StorageClass, error)
 	Delete(name string, options *api.DeleteOptions) error
 	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
-	Get(name string) (*extensions.StorageClass, error)
-	List(opts api.ListOptions) (*extensions.StorageClassList, error)
+	Get(name string) (*storage.StorageClass, error)
+	List(opts api.ListOptions) (*storage.StorageClassList, error)
 	Watch(opts api.ListOptions) (watch.Interface, error)
-	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *extensions.StorageClass, err error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *storage.StorageClass, err error)
 	StorageClassExpansion
 }
 
 // storageClasses implements StorageClassInterface
 type storageClasses struct {
-	client *ExtensionsClient
+	client *StorageClient
 }
 
 // newStorageClasses returns a StorageClasses
-func newStorageClasses(c *ExtensionsClient) *storageClasses {
+func newStorageClasses(c *StorageClient) *storageClasses {
 	return &storageClasses{
 		client: c,
 	}
 }
 
 // Create takes the representation of a storageClass and creates it.  Returns the server's representation of the storageClass, and an error, if there is any.
-func (c *storageClasses) Create(storageClass *extensions.StorageClass) (result *extensions.StorageClass, err error) {
-	result = &extensions.StorageClass{}
+func (c *storageClasses) Create(storageClass *storage.StorageClass) (result *storage.StorageClass, err error) {
+	result = &storage.StorageClass{}
 	err = c.client.Post().
 		Resource("storageclasses").
 		Body(storageClass).
@@ -65,8 +65,8 @@ func (c *storageClasses) Create(storageClass *extensions.StorageClass) (result *
 }
 
 // Update takes the representation of a storageClass and updates it. Returns the server's representation of the storageClass, and an error, if there is any.
-func (c *storageClasses) Update(storageClass *extensions.StorageClass) (result *extensions.StorageClass, err error) {
-	result = &extensions.StorageClass{}
+func (c *storageClasses) Update(storageClass *storage.StorageClass) (result *storage.StorageClass, err error) {
+	result = &storage.StorageClass{}
 	err = c.client.Put().
 		Resource("storageclasses").
 		Name(storageClass.Name).
@@ -97,8 +97,8 @@ func (c *storageClasses) DeleteCollection(options *api.DeleteOptions, listOption
 }
 
 // Get takes name of the storageClass, and returns the corresponding storageClass object, and an error if there is any.
-func (c *storageClasses) Get(name string) (result *extensions.StorageClass, err error) {
-	result = &extensions.StorageClass{}
+func (c *storageClasses) Get(name string) (result *storage.StorageClass, err error) {
+	result = &storage.StorageClass{}
 	err = c.client.Get().
 		Resource("storageclasses").
 		Name(name).
@@ -108,8 +108,8 @@ func (c *storageClasses) Get(name string) (result *extensions.StorageClass, err
 }
 
 // List takes label and field selectors, and returns the list of StorageClasses that match those selectors.
-func (c *storageClasses) List(opts api.ListOptions) (result *extensions.StorageClassList, err error) {
-	result = &extensions.StorageClassList{}
+func (c *storageClasses) List(opts api.ListOptions) (result *storage.StorageClassList, err error) {
+	result = &storage.StorageClassList{}
 	err = c.client.Get().
 		Resource("storageclasses").
 		VersionedParams(&opts, api.ParameterCodec).
@@ -128,8 +128,8 @@ func (c *storageClasses) Watch(opts api.ListOptions) (watch.Interface, error) {
 }
 
 // Patch applies the patch and returns the patched storageClass.
-func (c *storageClasses) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *extensions.StorageClass, err error) {
-	result = &extensions.StorageClass{}
+func (c *storageClasses) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *storage.StorageClass, err error) {
+	result = &storage.StorageClass{}
 	err = c.client.Patch(pt).
 		Resource("storageclasses").
 		SubResource(subresources...).

vendor/k8s.io/kubernetes/pkg/client/typed/discovery/discovery_client.go

@@ -20,6 +20,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/url"
+	"sort"
 	"strings"
 
 	"github.com/emicklei/go-restful/swagger"
@@ -31,7 +32,6 @@ import (
 	"k8s.io/kubernetes/pkg/client/restclient"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/runtime/serializer"
-	utilerrors "k8s.io/kubernetes/pkg/util/errors"
 	"k8s.io/kubernetes/pkg/version"
 )
 
@@ -149,9 +149,8 @@ func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (r
 		// ignore 403 or 404 error to be compatible with an v1.0 server.
 		if groupVersion == "v1" && (errors.IsNotFound(err) || errors.IsForbidden(err)) {
 			return resources, nil
-		} else {
-			return nil, err
 		}
+		return nil, err
 	}
 	return resources, nil
 }
@@ -174,6 +173,29 @@ func (d *DiscoveryClient) ServerResources() (map[string]*unversioned.APIResource
 	return result, nil
 }
 
+// ErrGroupDiscoveryFailed is returned if one or more API groups fail to load.
+type ErrGroupDiscoveryFailed struct {
+	// Groups is a list of the groups that failed to load and the error cause
+	Groups map[unversioned.GroupVersion]error
+}
+
+// Error implements the error interface
+func (e *ErrGroupDiscoveryFailed) Error() string {
+	var groups []string
+	for k, v := range e.Groups {
+		groups = append(groups, fmt.Sprintf("%s: %v", k, v))
+	}
+	sort.Strings(groups)
+	return fmt.Sprintf("unable to retrieve the complete list of server APIs: %s", strings.Join(groups, ", "))
+}
+
+// IsGroupDiscoveryFailedError returns true if the provided error indicates the server was unable to discover
+// a complete list of APIs for the client to use.
+func IsGroupDiscoveryFailedError(err error) bool {
+	_, ok := err.(*ErrGroupDiscoveryFailed)
+	return err != nil && ok
+}
+
 // 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) {
@@ -183,15 +205,18 @@ func (d *DiscoveryClient) serverPreferredResources(namespaced bool) ([]unversion
 		return results, err
 	}
 
-	allErrs := []error{}
+	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)
 		if err != nil {
-			allErrs = append(allErrs, err)
+			if failedGroups == nil {
+				failedGroups = make(map[unversioned.GroupVersion]error)
+			}
+			failedGroups[groupVersion] = err
 			continue
 		}
-		groupVersion := unversioned.GroupVersion{Group: apiGroup.Name, Version: preferredVersion.Version}
 		for _, apiResource := range apiResourceList.APIResources {
 			// ignore the root scoped resources if "namespaced" is true.
 			if namespaced && !apiResource.Namespaced {
@@ -203,7 +228,10 @@ func (d *DiscoveryClient) serverPreferredResources(namespaced bool) ([]unversion
 			results = append(results, groupVersion.WithResource(apiResource.Name))
 		}
 	}
-	return results, utilerrors.NewAggregate(allErrs)
+	if len(failedGroups) > 0 {
+		return results, &ErrGroupDiscoveryFailed{Groups: failedGroups}
+	}
+	return results, nil
 }
 
 // ServerPreferredResources returns the supported resources with the version preferred by the

vendor/k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset/clientset_adaption.go

@@ -24,6 +24,7 @@ import (
 	unversionedbatch "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned"
 	unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
 	unversionedextensions "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned"
+	unversionedstorage "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/storage/unversioned"
 	"k8s.io/kubernetes/pkg/client/typed/discovery"
 	"k8s.io/kubernetes/pkg/client/unversioned"
 )
@@ -68,6 +69,11 @@ func FromUnversionedClient(c *unversioned.Client) *internalclientset.Clientset {
 	} else {
 		clientset.DiscoveryClient = discovery.NewDiscoveryClient(nil)
 	}
+	if c != nil && c.StorageClient != nil {
+		clientset.StorageClient = unversionedstorage.New(c.StorageClient.RESTClient)
+	} else {
+		clientset.StorageClient = unversionedstorage.New(nil)
+	}
 
 	return &clientset
 }

vendor/k8s.io/kubernetes/pkg/client/unversioned/client.go

@@ -53,6 +53,7 @@ type Interface interface {
 	Rbac() RbacInterface
 	Discovery() discovery.DiscoveryInterface
 	Certificates() CertificatesInterface
+	Storage() StorageInterface
 }
 
 func (c *Client) ReplicationControllers(namespace string) ReplicationControllerInterface {
@@ -131,6 +132,7 @@ type Client struct {
 	*RbacClient
 	*discovery.DiscoveryClient
 	*CertificatesClient
+	*StorageClient
 }
 
 // IsTimeout tests if this is a timeout error in the underlying transport.
@@ -194,3 +196,7 @@ func (c *Client) Discovery() discovery.DiscoveryInterface {
 func (c *Client) Certificates() CertificatesInterface {
 	return c.CertificatesClient
 }
+
+func (c *Client) Storage() StorageInterface {
+	return c.StorageClient
+}

vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/client_config.go

@@ -329,7 +329,7 @@ func (config *DirectClientConfig) getCluster() clientcmdapi.Cluster {
 	clusterInfoName := config.getClusterName()
 
 	var mergedClusterInfo clientcmdapi.Cluster
-	mergo.Merge(&mergedClusterInfo, DefaultCluster)
+	mergo.Merge(&mergedClusterInfo, config.overrides.ClusterDefaults)
 	mergo.Merge(&mergedClusterInfo, EnvVarCluster)
 	if configClusterInfo, exists := clusterInfos[clusterInfoName]; exists {
 		mergo.Merge(&mergedClusterInfo, configClusterInfo)
@@ -350,6 +350,8 @@ func (config *DirectClientConfig) getCluster() clientcmdapi.Cluster {
 // inClusterClientConfig makes a config that will work from within a kubernetes cluster container environment.
 type inClusterClientConfig struct{}
 
+var _ ClientConfig = inClusterClientConfig{}
+
 func (inClusterClientConfig) RawConfig() (clientcmdapi.Config, error) {
 	return clientcmdapi.Config{}, fmt.Errorf("inCluster environment config doesn't support multiple clusters")
 }
@@ -358,21 +360,21 @@ func (inClusterClientConfig) ClientConfig() (*restclient.Config, error) {
 	return restclient.InClusterConfig()
 }
 
-func (inClusterClientConfig) Namespace() (string, error) {
+func (inClusterClientConfig) Namespace() (string, bool, error) {
 	// This way assumes you've set the POD_NAMESPACE environment variable using the downward API.
 	// This check has to be done first for backwards compatibility with the way InClusterConfig was originally set up
 	if ns := os.Getenv("POD_NAMESPACE"); ns != "" {
-		return ns, nil
+		return ns, true, nil
 	}
 
 	// Fall back to the namespace associated with the service account token, if available
 	if data, err := ioutil.ReadFile("/var/run/secrets/kubernetes.io/serviceaccount/namespace"); err == nil {
 		if ns := strings.TrimSpace(string(data)); len(ns) > 0 {
-			return ns, nil
+			return ns, true, nil
 		}
 	}
 
-	return "default", nil
+	return "default", false, nil
 }
 
 func (inClusterClientConfig) ConfigAccess() ConfigAccess {

vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/merged_client_builder.go

@@ -21,8 +21,6 @@ import (
 	"reflect"
 	"sync"
 
-	"github.com/golang/glog"
-
 	"k8s.io/kubernetes/pkg/client/restclient"
 	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
 )
@@ -39,16 +37,25 @@ type DeferredLoadingClientConfig struct {
 
 	clientConfig ClientConfig
 	loadingLock  sync.Mutex
+
+	// provided for testing
+	icc InClusterConfig
+}
+
+// InClusterConfig abstracts details of whether the client is running in a cluster for testing.
+type InClusterConfig interface {
+	ClientConfig
+	Possible() bool
 }
 
 // NewNonInteractiveDeferredLoadingClientConfig creates a ConfigClientClientConfig using the passed context name
 func NewNonInteractiveDeferredLoadingClientConfig(loader ClientConfigLoader, overrides *ConfigOverrides) ClientConfig {
-	return &DeferredLoadingClientConfig{loader: loader, overrides: overrides}
+	return &DeferredLoadingClientConfig{loader: loader, overrides: overrides, icc: inClusterClientConfig{}}
 }
 
 // NewInteractiveDeferredLoadingClientConfig creates a ConfigClientClientConfig using the passed context name and the fallback auth reader
 func NewInteractiveDeferredLoadingClientConfig(loader ClientConfigLoader, overrides *ConfigOverrides, fallbackReader io.Reader) ClientConfig {
-	return &DeferredLoadingClientConfig{loader: loader, overrides: overrides, fallbackReader: fallbackReader}
+	return &DeferredLoadingClientConfig{loader: loader, overrides: overrides, icc: inClusterClientConfig{}, fallbackReader: fallbackReader}
 }
 
 func (config *DeferredLoadingClientConfig) createClientConfig() (ClientConfig, error) {
@@ -92,18 +99,35 @@ func (config *DeferredLoadingClientConfig) ClientConfig() (*restclient.Config, e
 		return nil, err
 	}
 
+	// load the configuration and return on non-empty errors and if the
+	// content differs from the default config
 	mergedConfig, err := mergedClientConfig.ClientConfig()
-	if err != nil {
+	switch {
+	case err != nil && !IsEmptyConfig(err):
+		// return on any error except empty config
 		return nil, err
+	case mergedConfig != nil:
+		// if the configuration has any settings at all, we cannot use ICC
+		// TODO: we need to discriminate better between "empty due to env" and
+		//   "empty due to defaults"
+		// TODO: this shouldn't be a global - the client config rules should be
+		//   handling this.
+		defaultConfig, defErr := DefaultClientConfig.ClientConfig()
+		if IsConfigurationInvalid(defErr) && !IsEmptyConfig(err) {
+			return mergedConfig, nil
+		}
+		if defErr == nil && !reflect.DeepEqual(mergedConfig, defaultConfig) {
+			return mergedConfig, nil
+		}
 	}
-	// Are we running in a cluster and were no other configs found? If so, use the in-cluster-config.
-	icc := inClusterClientConfig{}
-	defaultConfig, err := DefaultClientConfig.ClientConfig()
-	if icc.Possible() && err == nil && reflect.DeepEqual(mergedConfig, defaultConfig) {
-		glog.V(2).Info("No kubeconfig could be created, falling back to service account.")
-		return icc.ClientConfig()
+
+	// check for in-cluster configuration and use it
+	if config.icc.Possible() {
+		return config.icc.ClientConfig()
 	}
-	return mergedConfig, nil
+
+	// return the result of the merged client config
+	return mergedConfig, err
 }
 
 // Namespace implements KubeConfig

vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/overrides.go

@@ -27,10 +27,12 @@ import (
 // ConfigOverrides holds values that should override whatever information is pulled from the actual Config object.  You can't
 // simply use an actual Config object, because Configs hold maps, but overrides are restricted to "at most one"
 type ConfigOverrides struct {
-	AuthInfo       clientcmdapi.AuthInfo
-	ClusterInfo    clientcmdapi.Cluster
-	Context        clientcmdapi.Context
-	CurrentContext string
+	AuthInfo clientcmdapi.AuthInfo
+	// ClusterDefaults are applied before the configured cluster info is loaded.
+	ClusterDefaults clientcmdapi.Cluster
+	ClusterInfo     clientcmdapi.Cluster
+	Context         clientcmdapi.Context
+	CurrentContext  string
 }
 
 // ConfigOverrideFlags holds the flag names to be used for binding command line flags.  Notice that this structure tightly

vendor/k8s.io/kubernetes/pkg/client/unversioned/extensions.go

@@ -35,7 +35,6 @@ type ExtensionsInterface interface {
 	ThirdPartyResourceNamespacer
 	ReplicaSetsNamespacer
 	PodSecurityPoliciesInterface
-	StorageClassesInterface
 }
 
 // ExtensionsClient is used to interact with experimental Kubernetes features.
@@ -81,10 +80,6 @@ func (c *ExtensionsClient) ReplicaSets(namespace string) ReplicaSetInterface {
 	return newReplicaSets(c, namespace)
 }
 
-func (c *ExtensionsClient) StorageClasses() StorageClassInterface {
-	return newStorageClasses(c)
-}
-
 // NewExtensions creates a new ExtensionsClient for the given config. This client
 // provides access to experimental Kubernetes features.
 // Features of Extensions group are not supported and may be changed or removed in

vendor/k8s.io/kubernetes/pkg/client/unversioned/helper.go

@@ -31,6 +31,7 @@ import (
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/apis/policy"
 	"k8s.io/kubernetes/pkg/apis/rbac"
+	"k8s.io/kubernetes/pkg/apis/storage"
 	"k8s.io/kubernetes/pkg/client/restclient"
 	"k8s.io/kubernetes/pkg/client/typed/discovery"
 	"k8s.io/kubernetes/pkg/util/sets"
@@ -143,6 +144,15 @@ func New(c *restclient.Config) (*Client, error) {
 		}
 	}
 
+	var storageClient *StorageClient
+	if registered.IsRegistered(storage.GroupName) {
+		storageConfig := *c
+		storageClient, err = NewStorage(&storageConfig)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	return &Client{
 		RESTClient:           client,
 		AppsClient:           appsClient,
@@ -155,6 +165,7 @@ func New(c *restclient.Config) (*Client, error) {
 		ExtensionsClient:     extensionsClient,
 		PolicyClient:         policyClient,
 		RbacClient:           rbacClient,
+		StorageClient:        storageClient,
 	}, nil
 }
 

vendor/k8s.io/kubernetes/pkg/client/unversioned/import_known_versions.go

@@ -32,6 +32,7 @@ import (
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
 	_ "k8s.io/kubernetes/pkg/apis/policy/install"
 	_ "k8s.io/kubernetes/pkg/apis/rbac/install"
+	_ "k8s.io/kubernetes/pkg/apis/storage/install"
 )
 
 func init() {

vendor/k8s.io/kubernetes/pkg/client/unversioned/storage.go

@@ -0,0 +1,77 @@
+/*
+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 unversioned
+
+import (
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
+	"k8s.io/kubernetes/pkg/apis/storage"
+	"k8s.io/kubernetes/pkg/client/restclient"
+)
+
+type StorageInterface interface {
+	StorageClassesInterface
+}
+
+// StorageClient is used to interact with Kubernetes storage features.
+type StorageClient struct {
+	*restclient.RESTClient
+}
+
+func (c *StorageClient) StorageClasses() StorageClassInterface {
+	return newStorageClasses(c)
+}
+
+func NewStorage(c *restclient.Config) (*StorageClient, error) {
+	config := *c
+	if err := setStorageDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := restclient.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &StorageClient{client}, nil
+}
+
+func NewStorageOrDie(c *restclient.Config) *StorageClient {
+	client, err := NewStorage(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+func setStorageDefaults(config *restclient.Config) error {
+	// if storage group is not registered, return an error
+	g, err := registered.Group(storage.GroupName)
+	if err != nil {
+		return err
+	}
+	config.APIPath = defaultAPIPath
+	if config.UserAgent == "" {
+		config.UserAgent = restclient.DefaultKubernetesUserAgent()
+	}
+	// TODO: Unconditionally set the config.Version, until we fix the config.
+	//if config.Version == "" {
+	copyGroupVersion := g.GroupVersion
+	config.GroupVersion = &copyGroupVersion
+	//}
+
+	config.NegotiatedSerializer = api.Codecs
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/client/unversioned/storageclasses.go

@@ -18,7 +18,7 @@ package unversioned
 
 import (
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/apis/storage"
 	"k8s.io/kubernetes/pkg/watch"
 )
 
@@ -28,25 +28,25 @@ type StorageClassesInterface interface {
 
 // StorageClassInterface has methods to work with StorageClass resources.
 type StorageClassInterface interface {
-	List(opts api.ListOptions) (*extensions.StorageClassList, error)
-	Get(name string) (*extensions.StorageClass, error)
-	Create(storageClass *extensions.StorageClass) (*extensions.StorageClass, error)
-	Update(storageClass *extensions.StorageClass) (*extensions.StorageClass, error)
+	List(opts api.ListOptions) (*storage.StorageClassList, error)
+	Get(name string) (*storage.StorageClass, error)
+	Create(storageClass *storage.StorageClass) (*storage.StorageClass, error)
+	Update(storageClass *storage.StorageClass) (*storage.StorageClass, error)
 	Delete(name string) error
 	Watch(opts api.ListOptions) (watch.Interface, error)
 }
 
 // storageClasses implements StorageClassInterface
 type storageClasses struct {
-	client *ExtensionsClient
+	client *StorageClient
 }
 
-func newStorageClasses(c *ExtensionsClient) *storageClasses {
+func newStorageClasses(c *StorageClient) *storageClasses {
 	return &storageClasses{c}
 }
 
-func (c *storageClasses) List(opts api.ListOptions) (result *extensions.StorageClassList, err error) {
-	result = &extensions.StorageClassList{}
+func (c *storageClasses) List(opts api.ListOptions) (result *storage.StorageClassList, err error) {
+	result = &storage.StorageClassList{}
 	err = c.client.Get().
 		Resource("storageclasses").
 		VersionedParams(&opts, api.ParameterCodec).
@@ -56,20 +56,20 @@ func (c *storageClasses) List(opts api.ListOptions) (result *extensions.StorageC
 	return result, err
 }
 
-func (c *storageClasses) Get(name string) (result *extensions.StorageClass, err error) {
-	result = &extensions.StorageClass{}
+func (c *storageClasses) Get(name string) (result *storage.StorageClass, err error) {
+	result = &storage.StorageClass{}
 	err = c.client.Get().Resource("storageClasses").Name(name).Do().Into(result)
 	return
 }
 
-func (c *storageClasses) Create(storageClass *extensions.StorageClass) (result *extensions.StorageClass, err error) {
-	result = &extensions.StorageClass{}
+func (c *storageClasses) Create(storageClass *storage.StorageClass) (result *storage.StorageClass, err error) {
+	result = &storage.StorageClass{}
 	err = c.client.Post().Resource("storageClasses").Body(storageClass).Do().Into(result)
 	return
 }
 
-func (c *storageClasses) Update(storageClass *extensions.StorageClass) (result *extensions.StorageClass, err error) {
-	result = &extensions.StorageClass{}
+func (c *storageClasses) Update(storageClass *storage.StorageClass) (result *storage.StorageClass, err error) {
+	result = &storage.StorageClass{}
 	err = c.client.Put().Resource("storageClasses").Name(storageClass.Name).Body(storageClass).Do().Into(result)
 	return
 }

vendor/k8s.io/kubernetes/pkg/client/unversioned/testclient/fake_storage_classes.go

@@ -18,7 +18,7 @@ package testclient
 
 import (
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/apis/storage"
 	kclientlib "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/watch"
 )
@@ -26,46 +26,46 @@ import (
 // FakeStorageClasses implements StorageClassInterface. 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 FakeStorageClasses struct {
-	Fake *FakeExperimental
+	Fake *FakeStorage
 }
 
 // Ensure statically that FakeStorageClasses implements StorageClassInterface.
 var _ kclientlib.StorageClassInterface = &FakeStorageClasses{}
 
-func (c *FakeStorageClasses) Get(name string) (*extensions.StorageClass, error) {
-	obj, err := c.Fake.Invokes(NewGetAction("storageclasses", "", name), &extensions.StorageClass{})
+func (c *FakeStorageClasses) Get(name string) (*storage.StorageClass, error) {
+	obj, err := c.Fake.Invokes(NewGetAction("storageclasses", "", name), &storage.StorageClass{})
 	if obj == nil {
 		return nil, err
 	}
-	return obj.(*extensions.StorageClass), err
+	return obj.(*storage.StorageClass), err
 }
 
-func (c *FakeStorageClasses) List(opts api.ListOptions) (*extensions.StorageClassList, error) {
-	obj, err := c.Fake.Invokes(NewListAction("storageclasses", "", opts), &extensions.StorageClassList{})
+func (c *FakeStorageClasses) List(opts api.ListOptions) (*storage.StorageClassList, error) {
+	obj, err := c.Fake.Invokes(NewListAction("storageclasses", "", opts), &storage.StorageClassList{})
 	if obj == nil {
 		return nil, err
 	}
-	return obj.(*extensions.StorageClassList), err
+	return obj.(*storage.StorageClassList), err
 }
 
-func (c *FakeStorageClasses) Create(np *extensions.StorageClass) (*extensions.StorageClass, error) {
-	obj, err := c.Fake.Invokes(NewCreateAction("storageclasses", "", np), &extensions.StorageClass{})
+func (c *FakeStorageClasses) Create(np *storage.StorageClass) (*storage.StorageClass, error) {
+	obj, err := c.Fake.Invokes(NewCreateAction("storageclasses", "", np), &storage.StorageClass{})
 	if obj == nil {
 		return nil, err
 	}
-	return obj.(*extensions.StorageClass), err
+	return obj.(*storage.StorageClass), err
 }
 
-func (c *FakeStorageClasses) Update(np *extensions.StorageClass) (*extensions.StorageClass, error) {
-	obj, err := c.Fake.Invokes(NewUpdateAction("storageclasses", "", np), &extensions.StorageClass{})
+func (c *FakeStorageClasses) Update(np *storage.StorageClass) (*storage.StorageClass, error) {
+	obj, err := c.Fake.Invokes(NewUpdateAction("storageclasses", "", np), &storage.StorageClass{})
 	if obj == nil {
 		return nil, err
 	}
-	return obj.(*extensions.StorageClass), err
+	return obj.(*storage.StorageClass), err
 }
 
 func (c *FakeStorageClasses) Delete(name string) error {
-	_, err := c.Fake.Invokes(NewDeleteAction("storageclasses", "", name), &extensions.StorageClass{})
+	_, err := c.Fake.Invokes(NewDeleteAction("storageclasses", "", name), &storage.StorageClass{})
 	return err
 }
 

vendor/k8s.io/kubernetes/pkg/client/unversioned/testclient/testclient.go

@@ -317,6 +317,10 @@ func (c *Fake) Rbac() client.RbacInterface {
 	return &FakeRbac{Fake: c}
 }
 
+func (c *Fake) Storage() client.StorageInterface {
+	return &FakeStorage{Fake: c}
+}
+
 func (c *Fake) Authentication() client.AuthenticationInterface {
 	return &FakeAuthentication{Fake: c}
 }
@@ -444,10 +448,6 @@ func (c *FakeExperimental) NetworkPolicies(namespace string) client.NetworkPolic
 	return &FakeNetworkPolicies{Fake: c, Namespace: namespace}
 }
 
-func (c *FakeExperimental) StorageClasses() client.StorageClassInterface {
-	return &FakeStorageClasses{Fake: c}
-}
-
 func NewSimpleFakeRbac(objects ...runtime.Object) *FakeRbac {
 	return &FakeRbac{Fake: NewSimpleFake(objects...)}
 }
@@ -472,6 +472,18 @@ func (c *FakeRbac) ClusterRoleBindings() client.ClusterRoleBindingInterface {
 	return &FakeClusterRoleBindings{Fake: c}
 }
 
+func NewSimpleFakeStorage(objects ...runtime.Object) *FakeStorage {
+	return &FakeStorage{Fake: NewSimpleFake(objects...)}
+}
+
+type FakeStorage struct {
+	*Fake
+}
+
+func (c *FakeStorage) StorageClasses() client.StorageClassInterface {
+	return &FakeStorageClasses{Fake: c}
+}
+
 type FakeDiscovery struct {
 	*Fake
 }