Update godeps

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
 }