Bumping k8s dependencies to 1.13

vendor/k8s.io/kubernetes/cmd/kubeadm/app/discovery/file/BUILD

@@ -12,13 +12,13 @@ go_library(
     deps = [
         "//cmd/kubeadm/app/constants:go_default_library",
         "//cmd/kubeadm/app/util/kubeconfig:go_default_library",
-        "//vendor/k8s.io/api/core/v1:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
-        "//vendor/k8s.io/client-go/tools/bootstrap/token/api:go_default_library",
-        "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
-        "//vendor/k8s.io/client-go/tools/clientcmd/api:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//staging/src/k8s.io/client-go/tools/bootstrap/token/api:go_default_library",
+        "//staging/src/k8s.io/client-go/tools/clientcmd:go_default_library",
+        "//staging/src/k8s.io/client-go/tools/clientcmd/api:go_default_library",
     ],
 )
 

vendor/k8s.io/kubernetes/cmd/kubeadm/app/discovery/file/file.go

@@ -18,7 +18,7 @@ package file
 
 import (
 	"fmt"
-
+	"io/ioutil"
 	"k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -30,39 +30,73 @@ import (
 	kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
 )
 
-// RetrieveValidatedClusterInfo connects to the API Server and makes sure it can talk
+// RetrieveValidatedConfigInfo connects to the API Server and makes sure it can talk
 // securely to the API Server using the provided CA cert and
 // optionally refreshes the cluster-info information from the cluster-info ConfigMap
-func RetrieveValidatedClusterInfo(filepath, clustername string) (*clientcmdapi.Cluster, error) {
-	clusterinfo, err := clientcmd.LoadFromFile(filepath)
+func RetrieveValidatedConfigInfo(filepath, clustername string) (*clientcmdapi.Config, error) {
+	config, err := clientcmd.LoadFromFile(filepath)
 	if err != nil {
 		return nil, err
 	}
-	return ValidateClusterInfo(clusterinfo, clustername)
+	return ValidateConfigInfo(config, clustername)
 }
 
-// ValidateClusterInfo connects to the API Server and makes sure it can talk
-// securely to the API Server using the provided CA cert and
+// ValidateConfigInfo connects to the API Server and makes sure it can talk
+// securely to the API Server using the provided CA cert/client certificates  and
 // optionally refreshes the cluster-info information from the cluster-info ConfigMap
-func ValidateClusterInfo(clusterinfo *clientcmdapi.Config, clustername string) (*clientcmdapi.Cluster, error) {
-	err := validateClusterInfoKubeConfig(clusterinfo)
+func ValidateConfigInfo(config *clientcmdapi.Config, clustername string) (*clientcmdapi.Config, error) {
+	err := validateKubeConfig(config)
 	if err != nil {
 		return nil, err
 	}
 
 	// This is the cluster object we've got from the cluster-info KubeConfig file
-	defaultCluster := kubeconfigutil.GetClusterFromKubeConfig(clusterinfo)
+	defaultCluster := kubeconfigutil.GetClusterFromKubeConfig(config)
 
 	// Create a new kubeconfig object from the given, just copy over the server and the CA cert
 	// We do this in order to not pick up other possible misconfigurations in the clusterinfo file
-	configFromClusterInfo := kubeconfigutil.CreateBasic(
+	kubeconfig := kubeconfigutil.CreateBasic(
 		defaultCluster.Server,
 		clustername,
 		"", // no user provided
 		defaultCluster.CertificateAuthorityData,
 	)
+	// load pre-existing client certificates
+	if config.Contexts[config.CurrentContext] != nil && len(config.AuthInfos) > 0 {
+		user := config.Contexts[config.CurrentContext].AuthInfo
+		authInfo, ok := config.AuthInfos[user]
+		if !ok || authInfo == nil {
+			return nil, fmt.Errorf("empty settings for user %q", user)
+		}
+		if len(authInfo.ClientCertificateData) == 0 && len(authInfo.ClientCertificate) != 0 {
+			clientCert, err := ioutil.ReadFile(authInfo.ClientCertificate)
+			if err != nil {
+				return nil, err
+			}
+			authInfo.ClientCertificateData = clientCert
+		}
+		if len(authInfo.ClientKeyData) == 0 && len(authInfo.ClientKey) != 0 {
+			clientKey, err := ioutil.ReadFile(authInfo.ClientKey)
+			if err != nil {
+				return nil, err
+			}
+			authInfo.ClientKeyData = clientKey
+		}
 
-	client, err := kubeconfigutil.ToClientSet(configFromClusterInfo)
+		if len(authInfo.ClientCertificateData) == 0 || len(authInfo.ClientKeyData) == 0 {
+			return nil, fmt.Errorf("couldn't read authentication info from the given kubeconfig file")
+		}
+		kubeconfig = kubeconfigutil.CreateWithCerts(
+			defaultCluster.Server,
+			clustername,
+			"", // no user provided
+			defaultCluster.CertificateAuthorityData,
+			authInfo.ClientKeyData,
+			authInfo.ClientCertificateData,
+		)
+	}
+
+	client, err := kubeconfigutil.ToClientSet(kubeconfig)
 	if err != nil {
 		return nil, err
 	}
@@ -88,19 +122,19 @@ func ValidateClusterInfo(clusterinfo *clientcmdapi.Config, clustername string) (
 
 	// If we couldn't fetch the cluster-info ConfigMap, just return the cluster-info object the user provided
 	if clusterinfoCM == nil {
-		return defaultCluster, nil
+		return kubeconfig, nil
 	}
 
 	// We somehow got hold of the ConfigMap, try to read some data from it. If we can't, fallback on the user-provided file
 	refreshedBaseKubeConfig, err := tryParseClusterInfoFromConfigMap(clusterinfoCM)
 	if err != nil {
 		fmt.Printf("[discovery] The %s ConfigMap isn't set up properly (%v), but the TLS cert is valid so proceeding...\n", bootstrapapi.ConfigMapClusterInfo, err)
-		return defaultCluster, nil
+		return kubeconfig, nil
 	}
 
 	fmt.Println("[discovery] Synced cluster-info information from the API Server so we have got the latest information")
 	// In an HA world in the future, this will make more sense, because now we've got new information, possibly about new API Servers to talk to
-	return kubeconfigutil.GetClusterFromKubeConfig(refreshedBaseKubeConfig), nil
+	return refreshedBaseKubeConfig, nil
 }
 
 // tryParseClusterInfoFromConfigMap tries to parse a kubeconfig file from a ConfigMap key
@@ -116,14 +150,14 @@ func tryParseClusterInfoFromConfigMap(cm *v1.ConfigMap) (*clientcmdapi.Config, e
 	return parsedKubeConfig, nil
 }
 
-// validateClusterInfoKubeConfig makes sure the user-provided cluster-info KubeConfig file is valid
-func validateClusterInfoKubeConfig(clusterinfo *clientcmdapi.Config) error {
-	if len(clusterinfo.Clusters) < 1 {
+// validateKubeConfig makes sure the user-provided KubeConfig file is valid
+func validateKubeConfig(config *clientcmdapi.Config) error {
+	if len(config.Clusters) < 1 {
 		return fmt.Errorf("the provided cluster-info KubeConfig file must have at least one Cluster defined")
 	}
-	defaultCluster := kubeconfigutil.GetClusterFromKubeConfig(clusterinfo)
+	defaultCluster := kubeconfigutil.GetClusterFromKubeConfig(config)
 	if defaultCluster == nil {
 		return fmt.Errorf("the provided cluster-info KubeConfig file must have an unnamed Cluster or a CurrentContext that specifies a non-nil Cluster")
 	}
-	return nil
+	return clientcmd.Validate(*config)
 }