Add glide.yaml and vendor deps

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "error.go",
+        "kubeconfig.go",
+        "tokens.go",
+        "version.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
+        "//cmd/kubeadm/app/preflight:go_default_library",
+        "//pkg/client/unversioned/clientcmd:go_default_library",
+        "//pkg/client/unversioned/clientcmd/api:go_default_library",
+        "//vendor:github.com/golang/glog",
+        "//vendor:github.com/renstrom/dedent",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "error_test.go",
+        "kubeconfig_test.go",
+        "tokens_test.go",
+        "version_test.go",
+    ],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
+        "//cmd/kubeadm/app/preflight:go_default_library",
+        "//pkg/client/unversioned/clientcmd/api:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/error.go

@@ -0,0 +1,92 @@
+/*
+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
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"k8s.io/kubernetes/cmd/kubeadm/app/preflight"
+
+	"github.com/golang/glog"
+	"github.com/renstrom/dedent"
+)
+
+const (
+	DefaultErrorExitCode = 1
+	PreFlight            = 2
+)
+
+var AlphaWarningOnExit = dedent.Dedent(`
+	kubeadm: I am an alpha version, my authors welcome your feedback and bug reports
+	kubeadm: please create an issue using https://github.com/kubernetes/kubernetes/issues/new
+	kubeadm: and make sure to mention @kubernetes/sig-cluster-lifecycle. Thank you!
+`)
+
+type debugError interface {
+	DebugError() (msg string, args []interface{})
+}
+
+var fatalErrHandler = fatal
+
+// BehaviorOnFatal allows you to override the default behavior when a fatal
+// error occurs, which is to call os.Exit(code). You can pass 'panic' as a function
+// here if you prefer the panic() over os.Exit(1).
+func BehaviorOnFatal(f func(string, int)) {
+	fatalErrHandler = f
+}
+
+// fatal prints the message if set and then exits. If V(2) or greater, glog.Fatal
+// is invoked for extended information.
+func fatal(msg string, code int) {
+	if len(msg) > 0 {
+		// add newline if needed
+		if !strings.HasSuffix(msg, "\n") {
+			msg += "\n"
+		}
+
+		if glog.V(2) {
+			glog.FatalDepth(2, msg)
+		}
+		fmt.Fprint(os.Stderr, msg)
+	}
+	os.Exit(code)
+}
+
+// CheckErr prints a user friendly error to STDERR and exits with a non-zero
+// exit code. Unrecognized errors will be printed with an "error: " prefix.
+//
+// This method is generic to the command in use and may be used by non-Kubectl
+// commands.
+func CheckErr(err error) {
+	checkErr("", err, fatalErrHandler)
+}
+
+// checkErr formats a given error as a string and calls the passed handleErr
+// func with that string and an kubectl exit code.
+func checkErr(prefix string, err error, handleErr func(string, int)) {
+	switch err.(type) {
+	case nil:
+		return
+	case *preflight.PreFlightError:
+		handleErr(err.Error(), PreFlight)
+	default:
+		fmt.Printf(AlphaWarningOnExit)
+		handleErr(err.Error(), DefaultErrorExitCode)
+	}
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/error_test.go

@@ -0,0 +1,52 @@
+/*
+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 util
+
+import (
+	"fmt"
+	"testing"
+
+	"k8s.io/kubernetes/cmd/kubeadm/app/preflight"
+)
+
+func TestCheckErr(t *testing.T) {
+	var codeReturned int
+	errHandle := func(err string, code int) {
+		codeReturned = code
+	}
+
+	var tokenTest = []struct {
+		e        error
+		expected int
+	}{
+		{nil, 0},
+		{fmt.Errorf(""), DefaultErrorExitCode},
+		{&preflight.PreFlightError{}, PreFlight},
+	}
+
+	for _, rt := range tokenTest {
+		codeReturned = 0
+		checkErr("", rt.e, errHandle)
+		if codeReturned != rt.expected {
+			t.Errorf(
+				"failed checkErr:\n\texpected: %d\n\t  actual: %d",
+				rt.expected,
+				codeReturned,
+			)
+		}
+	}
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig.go

@@ -0,0 +1,97 @@
+/*
+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 util
+
+import (
+	"fmt"
+	"os"
+	"path"
+
+	// TODO: "k8s.io/client-go/client/tools/clientcmd/api"
+	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+)
+
+func CreateBasicClientConfig(clusterName string, serverURL string, caCert []byte) *clientcmdapi.Config {
+	cluster := clientcmdapi.NewCluster()
+	cluster.Server = serverURL
+	cluster.CertificateAuthorityData = caCert
+
+	config := clientcmdapi.NewConfig()
+	config.Clusters[clusterName] = cluster
+
+	return config
+}
+
+func MakeClientConfigWithCerts(config *clientcmdapi.Config, clusterName string, userName string, clientKey []byte, clientCert []byte) *clientcmdapi.Config {
+	newConfig := config
+	name := fmt.Sprintf("%s@%s", userName, clusterName)
+
+	authInfo := clientcmdapi.NewAuthInfo()
+	authInfo.ClientKeyData = clientKey
+	authInfo.ClientCertificateData = clientCert
+
+	context := clientcmdapi.NewContext()
+	context.Cluster = clusterName
+	context.AuthInfo = userName
+
+	newConfig.AuthInfos[userName] = authInfo
+	newConfig.Contexts[name] = context
+	newConfig.CurrentContext = name
+
+	return newConfig
+}
+
+func MakeClientConfigWithToken(config *clientcmdapi.Config, clusterName string, userName string, token string) *clientcmdapi.Config {
+	newConfig := config
+	name := fmt.Sprintf("%s@%s", userName, clusterName)
+
+	authInfo := clientcmdapi.NewAuthInfo()
+	authInfo.Token = token
+
+	context := clientcmdapi.NewContext()
+	context.Cluster = clusterName
+	context.AuthInfo = userName
+
+	newConfig.AuthInfos[userName] = authInfo
+	newConfig.Contexts[name] = context
+	newConfig.CurrentContext = name
+
+	return newConfig
+}
+
+func WriteKubeconfigIfNotExists(name string, kubeconfig *clientcmdapi.Config) error {
+	if err := os.MkdirAll(kubeadmapi.GlobalEnvParams.KubernetesDir, 0700); err != nil {
+		return fmt.Errorf("<util/kubeconfig> failed to create directory %q [%v]", kubeadmapi.GlobalEnvParams.KubernetesDir, err)
+	}
+
+	filename := path.Join(kubeadmapi.GlobalEnvParams.KubernetesDir, fmt.Sprintf("%s.conf", name))
+	// Create and open the file, only if it does not already exist.
+	f, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_EXCL, 0600)
+	if err != nil {
+		return fmt.Errorf("<util/kubeconfig> failed to create %q, it already exists [%v]", filename, err)
+	}
+	f.Close()
+
+	if err := clientcmd.WriteToFile(*kubeconfig, filename); err != nil {
+		return fmt.Errorf("<util/kubeconfig> failed to write to %q [%v]", filename, err)
+	}
+
+	fmt.Printf("<util/kubeconfig> created %q\n", filename)
+	return nil
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig_test.go

@@ -0,0 +1,199 @@
+/*
+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 util
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+)
+
+const (
+	configOut1 = `apiVersion: v1
+clusters:
+- cluster:
+    server: ""
+  name: ""
+contexts: []
+current-context: ""
+kind: Config
+preferences: {}
+users: []
+`
+	configOut2 = `apiVersion: v1
+clusters:
+- cluster:
+    server: ""
+  name: kubernetes
+contexts: []
+current-context: ""
+kind: Config
+preferences: {}
+users: []
+`
+)
+
+type configClient struct {
+	c  string
+	s  string
+	ca []byte
+}
+
+type configClientWithCerts struct {
+	c           *clientcmdapi.Config
+	clusterName string
+	userName    string
+	clientKey   []byte
+	clientCert  []byte
+}
+
+type configClientWithToken struct {
+	c           *clientcmdapi.Config
+	clusterName string
+	userName    string
+	token       string
+}
+
+func TestCreateBasicClientConfig(t *testing.T) {
+	var createBasicTest = []struct {
+		cc       configClient
+		expected string
+	}{
+		{configClient{}, ""},
+		{configClient{c: "kubernetes"}, ""},
+	}
+	for _, rt := range createBasicTest {
+		c := CreateBasicClientConfig(rt.cc.c, rt.cc.s, rt.cc.ca)
+		if c.Kind != rt.expected {
+			t.Errorf(
+				"failed CreateBasicClientConfig:\n\texpected: %s\n\t  actual: %s",
+				c.Kind,
+				rt.expected,
+			)
+		}
+	}
+}
+
+func TestMakeClientConfigWithCerts(t *testing.T) {
+	var createBasicTest = []struct {
+		cc          configClient
+		ccWithCerts configClientWithCerts
+		expected    string
+	}{
+		{configClient{}, configClientWithCerts{}, ""},
+		{configClient{c: "kubernetes"}, configClientWithCerts{}, ""},
+	}
+	for _, rt := range createBasicTest {
+		c := CreateBasicClientConfig(rt.cc.c, rt.cc.s, rt.cc.ca)
+		rt.ccWithCerts.c = c
+		cwc := MakeClientConfigWithCerts(
+			rt.ccWithCerts.c,
+			rt.ccWithCerts.clusterName,
+			rt.ccWithCerts.userName,
+			rt.ccWithCerts.clientKey,
+			rt.ccWithCerts.clientCert,
+		)
+		if cwc.Kind != rt.expected {
+			t.Errorf(
+				"failed MakeClientConfigWithCerts:\n\texpected: %s\n\t  actual: %s",
+				c.Kind,
+				rt.expected,
+			)
+		}
+	}
+}
+
+func TestMakeClientConfigWithToken(t *testing.T) {
+	var createBasicTest = []struct {
+		cc          configClient
+		ccWithToken configClientWithToken
+		expected    string
+	}{
+		{configClient{}, configClientWithToken{}, ""},
+		{configClient{c: "kubernetes"}, configClientWithToken{}, ""},
+	}
+	for _, rt := range createBasicTest {
+		c := CreateBasicClientConfig(rt.cc.c, rt.cc.s, rt.cc.ca)
+		rt.ccWithToken.c = c
+		cwc := MakeClientConfigWithToken(
+			rt.ccWithToken.c,
+			rt.ccWithToken.clusterName,
+			rt.ccWithToken.userName,
+			rt.ccWithToken.token,
+		)
+		if cwc.Kind != rt.expected {
+			t.Errorf(
+				"failed MakeClientConfigWithCerts:\n\texpected: %s\n\t  actual: %s",
+				c.Kind,
+				rt.expected,
+			)
+		}
+	}
+}
+
+func TestWriteKubeconfigIfNotExists(t *testing.T) {
+	tmpdir, err := ioutil.TempDir("", "")
+	if err != nil {
+		t.Fatalf("Couldn't create tmpdir")
+	}
+	defer os.Remove(tmpdir)
+
+	// set up tmp GlobalEnvParams values for testing
+	oldEnv := kubeadmapi.GlobalEnvParams
+	kubeadmapi.GlobalEnvParams = kubeadmapi.SetEnvParams()
+	kubeadmapi.GlobalEnvParams.KubernetesDir = fmt.Sprintf("%s/etc/kubernetes", tmpdir)
+	kubeadmapi.GlobalEnvParams.HostPKIPath = fmt.Sprintf("%s/etc/kubernetes/pki", tmpdir)
+	kubeadmapi.GlobalEnvParams.HostEtcdPath = fmt.Sprintf("%s/var/lib/etcd", tmpdir)
+	kubeadmapi.GlobalEnvParams.DiscoveryImage = fmt.Sprintf("%s/var/lib/etcd", tmpdir)
+	defer func() { kubeadmapi.GlobalEnvParams = oldEnv }()
+
+	var writeConfig = []struct {
+		name     string
+		cc       configClient
+		expected error
+		file     []byte
+	}{
+		{"test1", configClient{}, nil, []byte(configOut1)},
+		{"test2", configClient{c: "kubernetes"}, nil, []byte(configOut2)},
+	}
+	for _, rt := range writeConfig {
+		c := CreateBasicClientConfig(rt.cc.c, rt.cc.s, rt.cc.ca)
+		err := WriteKubeconfigIfNotExists(rt.name, c)
+		if err != rt.expected {
+			t.Errorf(
+				"failed WriteKubeconfigIfNotExists with an error:\n\texpected: %s\n\t  actual: %s",
+				err,
+				rt.expected,
+			)
+		}
+		configPath := filepath.Join(kubeadmapi.GlobalEnvParams.KubernetesDir, fmt.Sprintf("%s.conf", rt.name))
+		newFile, err := ioutil.ReadFile(configPath)
+		if !bytes.Equal(newFile, rt.file) {
+			t.Errorf(
+				"failed WriteKubeconfigIfNotExists config write:\n\texpected: %s\n\t  actual: %s",
+				newFile,
+				rt.file,
+			)
+		}
+	}
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/tokens.go

@@ -0,0 +1,84 @@
+/*
+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 util
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"strings"
+
+	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
+)
+
+const (
+	TokenIDLen = 6
+	TokenBytes = 8
+)
+
+func RandBytes(length int) ([]byte, string, error) {
+	b := make([]byte, length)
+	_, err := rand.Read(b)
+	if err != nil {
+		return nil, "", err
+	}
+	// It's only the tokenID that doesn't care about raw byte slice,
+	// so we just encoded it in place and ignore bytes slice where we
+	// do not want it
+	return b, hex.EncodeToString(b), nil
+}
+
+func GenerateToken(s *kubeadmapi.Secrets) error {
+	_, tokenID, err := RandBytes(TokenIDLen / 2)
+	if err != nil {
+		return err
+	}
+
+	tokenBytes, token, err := RandBytes(TokenBytes)
+	if err != nil {
+		return err
+	}
+
+	s.TokenID = tokenID
+	s.BearerToken = token
+	s.Token = tokenBytes
+	s.GivenToken = fmt.Sprintf("%s.%s", tokenID, token)
+	return nil
+}
+
+func UseGivenTokenIfValid(s *kubeadmapi.Secrets) (bool, error) {
+	if s.GivenToken == "" {
+		return false, nil // not given
+	}
+	fmt.Println("<util/tokens> validating provided token")
+	givenToken := strings.Split(strings.ToLower(s.GivenToken), ".")
+	// TODO(phase1+) could also print more specific messages in each case
+	invalidErr := "<util/tokens> provided token does not match expected <6 characters>.<16 characters> format - %s"
+	if len(givenToken) != 2 {
+		return false, fmt.Errorf(invalidErr, "not in 2-part dot-separated format")
+	}
+	if len(givenToken[0]) != TokenIDLen {
+		return false, fmt.Errorf(invalidErr, fmt.Sprintf(
+			"length of first part is incorrect [%d (given) != %d (expected) ]",
+			len(givenToken[0]), TokenIDLen))
+	}
+	tokenBytes := []byte(givenToken[1])
+	s.TokenID = givenToken[0]
+	s.BearerToken = givenToken[1]
+	s.Token = tokenBytes
+	return true, nil // given and valid
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/tokens_test.go

@@ -0,0 +1,201 @@
+/*
+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 util
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
+)
+
+func TestUsingEmptyTokenFails(t *testing.T) {
+	// Simulates what happens when you omit --token on the CLI
+	s := newSecretsWithToken("")
+
+	given, err := UseGivenTokenIfValid(s)
+	if err != nil {
+		t.Errorf("UseGivenTokenIfValid returned an error when the token was omitted: %v", err)
+	}
+	if given {
+		t.Error("UseGivenTokenIfValid returned given = true when the token was omitted; expected false")
+	}
+}
+
+func TestTokenValidationFailures(t *testing.T) {
+	var tests = []struct {
+		t        string
+		expected bool
+	}{
+		{
+			t:        "1234567890123456789012",
+			expected: false,
+		},
+		{
+			t:        "12345.1234567890123456",
+			expected: false,
+		},
+		{
+			t:        ".1234567890123456",
+			expected: false,
+		},
+		{
+			t:        "123456.1234567890.123456",
+			expected: false,
+		},
+	}
+
+	for _, rt := range tests {
+		s := newSecretsWithToken(rt.t)
+		_, err := UseGivenTokenIfValid(s)
+		if (err == nil) != rt.expected {
+			t.Errorf(
+				"failed UseGivenTokenIfValid and did not return an error for this invalid token: [%s]",
+				rt.t,
+			)
+		}
+	}
+}
+
+func TestValidTokenPopulatesSecrets(t *testing.T) {
+	var tests = []struct {
+		token               string
+		expectedToken       []byte
+		expectedTokenID     string
+		expectedBearerToken string
+	}{
+		{
+			token:               "123456.0123456789AbCdEf",
+			expectedToken:       []byte("0123456789abcdef"),
+			expectedTokenID:     "123456",
+			expectedBearerToken: "0123456789abcdef",
+		},
+	}
+
+	for _, rt := range tests {
+		s := newSecretsWithToken(rt.token)
+
+		given, err := UseGivenTokenIfValid(s)
+		if err != nil {
+			t.Errorf("UseGivenTokenIfValid gave an error for a valid token: %v", err)
+		}
+		if !given {
+			t.Error("UseGivenTokenIfValid returned given = false when given a valid token")
+		}
+		if s.TokenID != rt.expectedTokenID {
+			t.Errorf("UseGivenTokenIfValid did not populate the TokenID correctly; expected [%s] but got [%s]", rt.expectedTokenID, s.TokenID)
+		}
+		if s.BearerToken != rt.expectedBearerToken {
+			t.Errorf("UseGivenTokenIfValid did not populate the BearerToken correctly; expected [%s] but got [%s]", rt.expectedBearerToken, s.BearerToken)
+		}
+		if !bytes.Equal(s.Token, rt.expectedToken) {
+			t.Errorf("UseGivenTokenIfValid did not populate the Token correctly; expected %v but got %v", rt.expectedToken, s.Token)
+		}
+	}
+}
+
+func newSecretsWithToken(token string) *kubeadmapi.Secrets {
+	s := new(kubeadmapi.Secrets)
+	s.GivenToken = token
+	return s
+}
+
+func TestGenerateToken(t *testing.T) {
+	var genTest = []struct {
+		s kubeadmapi.Secrets
+		l int
+		n int
+	}{
+		{kubeadmapi.Secrets{}, 2, 6},
+	}
+
+	for _, rt := range genTest {
+		GenerateToken(&rt.s)
+		givenToken := strings.Split(strings.ToLower(rt.s.GivenToken), ".")
+		if len(givenToken) != rt.l {
+			t.Errorf(
+				"failed GenerateToken num parts:\n\texpected: %d\n\t  actual: %d",
+				rt.l,
+				len(givenToken),
+			)
+		}
+		if len(givenToken[0]) != rt.n {
+			t.Errorf(
+				"failed GenerateToken first part length:\n\texpected: %d\n\t  actual: %d",
+				rt.l,
+				len(givenToken),
+			)
+		}
+	}
+}
+
+func TestUseGivenTokenIfValid(t *testing.T) {
+	var tokenTest = []struct {
+		s        kubeadmapi.Secrets
+		expected bool
+	}{
+		{kubeadmapi.Secrets{GivenToken: ""}, false},         // GivenToken == ""
+		{kubeadmapi.Secrets{GivenToken: "noperiod"}, false}, // not 2-part '.' format
+		{kubeadmapi.Secrets{GivenToken: "abcd.a"}, false},   // len(tokenID) != 6
+		{kubeadmapi.Secrets{GivenToken: "abcdef.a"}, true},
+	}
+
+	for _, rt := range tokenTest {
+		actual, _ := UseGivenTokenIfValid(&rt.s)
+		if actual != rt.expected {
+			t.Errorf(
+				"failed UseGivenTokenIfValid:\n\texpected: %t\n\t  actual: %t\n\t token:%s",
+				rt.expected,
+				actual,
+				rt.s.GivenToken,
+			)
+		}
+	}
+}
+
+func TestRandBytes(t *testing.T) {
+	var randTest = []struct {
+		r        int
+		l        int
+		expected error
+	}{
+		{0, 0, nil},
+		{1, 1, nil},
+		{2, 2, nil},
+		{3, 3, nil},
+		{100, 100, nil},
+	}
+
+	for _, rt := range randTest {
+		actual, _, err := RandBytes(rt.r)
+		if err != rt.expected {
+			t.Errorf(
+				"failed RandBytes:\n\texpected: %s\n\t  actual: %s",
+				rt.expected,
+				err,
+			)
+		}
+		if len(actual) != rt.l {
+			t.Errorf(
+				"failed RandBytes:\n\texpected: %d\n\t  actual: %d\n",
+				rt.l,
+				len(actual),
+			)
+		}
+	}
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/version.go

@@ -0,0 +1,71 @@
+/*
+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 util
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"regexp"
+	"strings"
+)
+
+var (
+	kubeReleaseBucketURL  = "https://storage.googleapis.com/kubernetes-release/release"
+	kubeReleaseRegex      = regexp.MustCompile(`^v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)([-0-9a-zA-Z_\.+]*)?$`)
+	kubeReleaseLabelRegex = regexp.MustCompile(`^[[:lower:]]+(-[-\w_\.]+)?$`)
+)
+
+// KubernetesReleaseVersion is helper function that can fetch
+// available version information from release servers based on
+// label names, like "stable" or "latest".
+//
+// If argument is already semantic version string, it
+// will return same string.
+//
+// In case of labels, it tries to fetch from release
+// servers and then return actual semantic version.
+//
+// Available names on release servers:
+//  stable      (latest stable release)
+//  stable-1    (latest stable release in 1.x)
+//  stable-1.0  (and similarly 1.1, 1.2, 1.3, ...)
+//  latest      (latest release, including alpha/beta)
+//  latest-1    (latest release in 1.x, including alpha/beta)
+//  latest-1.0  (and similarly 1.1, 1.2, 1.3, ...)
+func KubernetesReleaseVersion(version string) (string, error) {
+	if kubeReleaseRegex.MatchString(version) {
+		return version, nil
+	} else if kubeReleaseLabelRegex.MatchString(version) {
+		url := fmt.Sprintf("%s/%s.txt", kubeReleaseBucketURL, version)
+		resp, err := http.Get(url)
+		if err != nil {
+			return "", fmt.Errorf("Error: unable to get URL %q: %s", url, err.Error())
+		}
+		defer resp.Body.Close()
+		if resp.StatusCode != http.StatusOK {
+			return "", fmt.Errorf("Error: unable to fetch release information. URL: %q Status: %v", url, resp.Status)
+		}
+		body, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return "", fmt.Errorf("Error: unable to read content of URL %q: %s", url, err.Error())
+		}
+		// Re-validate received version and return.
+		return KubernetesReleaseVersion(strings.Trim(string(body), " \t\n"))
+	}
+	return "", fmt.Errorf("Error: version %q doesn't match patterns for neither semantic version nor labels (stable, latest, ...)", version)
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/version_test.go

@@ -0,0 +1,122 @@
+/*
+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 util
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"path"
+	"strings"
+	"testing"
+)
+
+func TestEmptyVersion(t *testing.T) {
+
+	ver, err := KubernetesReleaseVersion("")
+	if err == nil {
+		t.Error("KubernetesReleaseVersion returned succesfully, but error expected")
+	}
+	if ver != "" {
+		t.Error("KubernetesReleaseVersion returned value, expected only error")
+	}
+}
+
+func TestValidVersion(t *testing.T) {
+	validVersions := []string{
+		"v1.3.0",
+		"v1.4.0-alpha.0",
+		"v1.4.5",
+		"v1.4.0-beta.0",
+		"v2.0.0",
+		"v1.6.0-alpha.0.536+d60d9f3269288f",
+		"v1.5.0-alpha.0.1078+1044b6822497da-pull",
+		"v1.5.0-alpha.1.822+49b9e32fad9f32-pull-gke-gci",
+	}
+	for _, s := range validVersions {
+		ver, err := KubernetesReleaseVersion(s)
+		t.Log("Valid: ", s, ver, err)
+		if err != nil {
+			t.Errorf("KubernetesReleaseVersion unexpected error for version %q: %v", s, err)
+		}
+		if ver != s {
+			t.Errorf("KubernetesReleaseVersion should return same valid version string. %q != %q", s, ver)
+		}
+	}
+}
+
+func TestInvalidVersion(t *testing.T) {
+	invalidVersions := []string{
+		"v1.3",
+		"1.4.0",
+		"1.4.5+git",
+		"something1.2",
+	}
+	for _, s := range invalidVersions {
+		ver, err := KubernetesReleaseVersion(s)
+		t.Log("Invalid: ", s, ver, err)
+		if err == nil {
+			t.Errorf("KubernetesReleaseVersion error expected for version %q, but returned succesfully", s)
+		}
+		if ver != "" {
+			t.Errorf("KubernetesReleaseVersion should return empty string in case of error. Returned %q for version %q", ver, s)
+		}
+	}
+}
+
+func TestVersionFromNetwork(t *testing.T) {
+	type T struct {
+		Content       string
+		Status        int
+		Expected      string
+		ErrorExpected bool
+	}
+	cases := map[string]T{
+		"stable":     {"stable-1", http.StatusOK, "v1.4.6", false}, // recursive pointer to stable-1
+		"stable-1":   {"v1.4.6", http.StatusOK, "v1.4.6", false},
+		"stable-1.3": {"v1.3.10", http.StatusOK, "v1.3.10", false},
+		"latest":     {"v1.6.0-alpha.0", http.StatusOK, "v1.6.0-alpha.0", false},
+		"latest-1.3": {"v1.3.11-beta.0", http.StatusOK, "v1.3.11-beta.0", false},
+		"empty":      {"", http.StatusOK, "", true},
+		"garbage":    {"<?xml version='1.0'?><Error><Code>NoSuchKey</Code><Message>The specified key does not exist.</Message></Error>", http.StatusOK, "", true},
+		"unknown":    {"The requested URL was not found on this server.", http.StatusNotFound, "", true},
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		key := strings.TrimSuffix(path.Base(r.URL.Path), ".txt")
+		res, found := cases[key]
+		if found {
+			http.Error(w, res.Content, res.Status)
+		} else {
+			http.Error(w, "Unknown test case key!", http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	kubeReleaseBucketURL = server.URL
+
+	for k, v := range cases {
+		ver, err := KubernetesReleaseVersion(k)
+		t.Logf("Key: %q. Result: %q, Error: %v", k, ver, err)
+		switch {
+		case err != nil && !v.ErrorExpected:
+			t.Errorf("KubernetesReleaseVersion: unexpected error for %q. Error: %v", k, err)
+		case err == nil && v.ErrorExpected:
+			t.Errorf("KubernetesReleaseVersion: error expected for key %q, but result is %q", k, ver)
+		case ver != v.Expected:
+			t.Errorf("KubernetesReleaseVersion: unexpected result for key %q. Expected: %q Actual: %q", k, v.Expected, ver)
+		}
+	}
+}