Merge pull request #75179 from rosti/kill-v1alpha3

cmd/kubeadm/app/apis/kubeadm/BUILD

@@ -43,7 +43,6 @@ filegroup(
         ":package-srcs",
         "//cmd/kubeadm/app/apis/kubeadm/fuzzer:all-srcs",
         "//cmd/kubeadm/app/apis/kubeadm/scheme:all-srcs",
-        "//cmd/kubeadm/app/apis/kubeadm/v1alpha3:all-srcs",
         "//cmd/kubeadm/app/apis/kubeadm/v1beta1:all-srcs",
         "//cmd/kubeadm/app/apis/kubeadm/validation:all-srcs",
     ],

cmd/kubeadm/app/apis/kubeadm/fuzzer/fuzzer.go

@@ -98,8 +98,7 @@ func fuzzClusterConfiguration(obj *kubeadm.ClusterConfiguration, c fuzz.Continue
 }
 
 func fuzzDNS(obj *kubeadm.DNS, c fuzz.Continue) {
-	// This is intentionally not calling c.FuzzNoCustom because DNS struct does not exists in v1alpha3 api
-	// (so no random value will be applied, and this is necessary for getting roundtrip passing)
+	c.FuzzNoCustom(obj)
 
 	// Pinning values for fields that get defaults if fuzz value is empty string or nil
 	obj.Type = kubeadm.CoreDNS
@@ -115,10 +114,6 @@ func fuzzLocalEtcd(obj *kubeadm.LocalEtcd, c fuzz.Continue) {
 
 	// Pinning values for fields that get defaults if fuzz value is empty string or nil (thus making the round trip test fail)
 	obj.DataDir = "foo"
-
-	// Pinning values for fields that does not exists in v1alpha3 api
-	obj.ImageRepository = ""
-	obj.ImageTag = ""
 }
 
 func fuzzNetworking(obj *kubeadm.Networking, c fuzz.Continue) {

cmd/kubeadm/app/apis/kubeadm/scheme/BUILD

@@ -7,7 +7,6 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
-        "//cmd/kubeadm/app/apis/kubeadm/v1alpha3:go_default_library",
         "//cmd/kubeadm/app/apis/kubeadm/v1beta1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",

cmd/kubeadm/app/apis/kubeadm/scheme/scheme.go

@@ -23,7 +23,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta1"
 )
 
@@ -41,7 +40,6 @@ func init() {
 // AddToScheme builds the kubeadm scheme using all known versions of the kubeadm api.
 func AddToScheme(scheme *runtime.Scheme) {
 	utilruntime.Must(kubeadm.AddToScheme(scheme))
-	utilruntime.Must(v1alpha3.AddToScheme(scheme))
 	utilruntime.Must(v1beta1.AddToScheme(scheme))
 	utilruntime.Must(scheme.SetVersionPriority(v1beta1.SchemeGroupVersion))
 }

cmd/kubeadm/app/apis/kubeadm/v1alpha3/BUILD

-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "bootstraptokenstring.go",
-        "conversion.go",
-        "defaults.go",
-        "defaults_unix.go",
-        "defaults_windows.go",
-        "doc.go",
-        "register.go",
-        "types.go",
-        "zz_generated.conversion.go",
-        "zz_generated.deepcopy.go",
-        "zz_generated.defaults.go",
-    ],
-    importpath = "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha3",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
-        "//cmd/kubeadm/app/constants:go_default_library",
-        "//cmd/kubeadm/app/features:go_default_library",
-        "//cmd/kubeadm/app/images:go_default_library",
-        "//cmd/kubeadm/app/util:go_default_library",
-        "//staging/src/k8s.io/api/core/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/conversion:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
-        "//staging/src/k8s.io/cluster-bootstrap/token/api:go_default_library",
-        "//staging/src/k8s.io/cluster-bootstrap/token/util:go_default_library",
-        "//vendor/github.com/pkg/errors:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "bootstraptokenstring_test.go",
-        "conversion_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
-        "//vendor/github.com/pkg/errors:go_default_library",
-    ],
-)

cmd/kubeadm/app/apis/kubeadm/v1alpha3/bootstraptokenstring.go

-/*
-Copyright 2018 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 v1alpha3
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/pkg/errors"
-
-	bootstrapapi "k8s.io/cluster-bootstrap/token/api"
-	bootstraputil "k8s.io/cluster-bootstrap/token/util"
-)
-
-// BootstrapTokenString is a token of the format abcdef.abcdef0123456789 that is used
-// for both validation of the practically of the API server from a joining node's point
-// of view and as an authentication method for the node in the bootstrap phase of
-// "kubeadm join". This token is and should be short-lived
-type BootstrapTokenString struct {
-	ID     string
-	Secret string
-}
-
-// MarshalJSON implements the json.Marshaler interface.
-func (bts BootstrapTokenString) MarshalJSON() ([]byte, error) {
-	return []byte(fmt.Sprintf(`"%s"`, bts.String())), nil
-}
-
-// UnmarshalJSON implements the json.Unmarshaller interface.
-func (bts *BootstrapTokenString) UnmarshalJSON(b []byte) error {
-	// If the token is represented as "", just return quickly without an error
-	if len(b) == 0 {
-		return nil
-	}
-
-	// Remove unnecessary " characters coming from the JSON parser
-	token := strings.Replace(string(b), `"`, ``, -1)
-	// Convert the string Token to a BootstrapTokenString object
-	newbts, err := NewBootstrapTokenString(token)
-	if err != nil {
-		return err
-	}
-	bts.ID = newbts.ID
-	bts.Secret = newbts.Secret
-	return nil
-}
-
-// String returns the string representation of the BootstrapTokenString
-func (bts BootstrapTokenString) String() string {
-	if len(bts.ID) > 0 && len(bts.Secret) > 0 {
-		return bootstraputil.TokenFromIDAndSecret(bts.ID, bts.Secret)
-	}
-	return ""
-}
-
-// NewBootstrapTokenString converts the given Bootstrap Token as a string
-// to the BootstrapTokenString object used for serialization/deserialization
-// and internal usage. It also automatically validates that the given token
-// is of the right format
-func NewBootstrapTokenString(token string) (*BootstrapTokenString, error) {
-	substrs := bootstraputil.BootstrapTokenRegexp.FindStringSubmatch(token)
-	// TODO: Add a constant for the 3 value here, and explain better why it's needed (other than because how the regexp parsin works)
-	if len(substrs) != 3 {
-		return nil, errors.Errorf("the bootstrap token %q was not of the form %q", token, bootstrapapi.BootstrapTokenPattern)
-	}
-
-	return &BootstrapTokenString{ID: substrs[1], Secret: substrs[2]}, nil
-}
-
-// NewBootstrapTokenStringFromIDAndSecret is a wrapper around NewBootstrapTokenString
-// that allows the caller to specify the ID and Secret separately
-func NewBootstrapTokenStringFromIDAndSecret(id, secret string) (*BootstrapTokenString, error) {
-	return NewBootstrapTokenString(bootstraputil.TokenFromIDAndSecret(id, secret))
-}

cmd/kubeadm/app/apis/kubeadm/v1alpha3/bootstraptokenstring_test.go

-/*
-Copyright 2018 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 v1alpha3
-
-import (
-	"encoding/json"
-	"reflect"
-	"testing"
-
-	"github.com/pkg/errors"
-)
-
-func TestMarshalJSON(t *testing.T) {
-	var tests = []struct {
-		bts      BootstrapTokenString
-		expected string
-	}{
-		{BootstrapTokenString{ID: "abcdef", Secret: "abcdef0123456789"}, `"abcdef.abcdef0123456789"`},
-		{BootstrapTokenString{ID: "foo", Secret: "bar"}, `"foo.bar"`},
-		{BootstrapTokenString{ID: "h", Secret: "b"}, `"h.b"`},
-	}
-	for _, rt := range tests {
-		t.Run(rt.bts.ID, func(t *testing.T) {
-			b, err := json.Marshal(rt.bts)
-			if err != nil {
-				t.Fatalf("json.Marshal returned an unexpected error: %v", err)
-			}
-			if string(b) != rt.expected {
-				t.Errorf(
-					"failed BootstrapTokenString.MarshalJSON:\n\texpected: %s\n\t  actual: %s",
-					rt.expected,
-					string(b),
-				)
-			}
-		})
-	}
-}
-
-func TestUnmarshalJSON(t *testing.T) {
-	var tests = []struct {
-		input         string
-		bts           *BootstrapTokenString
-		expectedError bool
-	}{
-		{`"f.s"`, &BootstrapTokenString{}, true},
-		{`"abcdef."`, &BootstrapTokenString{}, true},
-		{`"abcdef:abcdef0123456789"`, &BootstrapTokenString{}, true},
-		{`abcdef.abcdef0123456789`, &BootstrapTokenString{}, true},
-		{`"abcdef.abcdef0123456789`, &BootstrapTokenString{}, true},
-		{`"abcdef.ABCDEF0123456789"`, &BootstrapTokenString{}, true},
-		{`"abcdef.abcdef0123456789"`, &BootstrapTokenString{ID: "abcdef", Secret: "abcdef0123456789"}, false},
-		{`"123456.aabbccddeeffgghh"`, &BootstrapTokenString{ID: "123456", Secret: "aabbccddeeffgghh"}, false},
-	}
-	for _, rt := range tests {
-		t.Run(rt.input, func(t *testing.T) {
-			newbts := &BootstrapTokenString{}
-			err := json.Unmarshal([]byte(rt.input), newbts)
-			if (err != nil) != rt.expectedError {
-				t.Errorf("failed BootstrapTokenString.UnmarshalJSON:\n\texpected error: %t\n\t  actual error: %v", rt.expectedError, err)
-			} else if !reflect.DeepEqual(rt.bts, newbts) {
-				t.Errorf(
-					"failed BootstrapTokenString.UnmarshalJSON:\n\texpected: %v\n\t  actual: %v",
-					rt.bts,
-					newbts,
-				)
-			}
-		})
-	}
-}
-
-func TestJSONRoundtrip(t *testing.T) {
-	var tests = []struct {
-		input string
-		bts   *BootstrapTokenString
-	}{
-		{`"abcdef.abcdef0123456789"`, nil},
-		{"", &BootstrapTokenString{ID: "abcdef", Secret: "abcdef0123456789"}},
-	}
-	for _, rt := range tests {
-		t.Run(rt.input, func(t *testing.T) {
-			if err := roundtrip(rt.input, rt.bts); err != nil {
-				t.Errorf("failed BootstrapTokenString JSON roundtrip with error: %v", err)
-			}
-		})
-	}
-}
-
-func roundtrip(input string, bts *BootstrapTokenString) error {
-	var b []byte
-	var err error
-	newbts := &BootstrapTokenString{}
-	// If string input was specified, roundtrip like this: string -> (unmarshal) -> object -> (marshal) -> string
-	if len(input) > 0 {
-		if err := json.Unmarshal([]byte(input), newbts); err != nil {
-			return errors.Wrap(err, "expected no unmarshal error, got error")
-		}
-		if b, err = json.Marshal(newbts); err != nil {
-			return errors.Wrap(err, "expected no marshal error, got error")
-		}
-		if input != string(b) {
-			return errors.Errorf(
-				"expected token: %s\n\t  actual: %s",
-				input,
-				string(b),
-			)
-		}
-	} else { // Otherwise, roundtrip like this: object -> (marshal) -> string -> (unmarshal) -> object
-		if b, err = json.Marshal(bts); err != nil {
-			return errors.Wrap(err, "expected no marshal error, got error")
-		}
-		if err := json.Unmarshal(b, newbts); err != nil {
-			return errors.Wrap(err, "expected no unmarshal error, got error")
-		}
-		if !reflect.DeepEqual(bts, newbts) {
-			return errors.Errorf(
-				"expected object: %v\n\t  actual: %v",
-				bts,
-				newbts,
-			)
-		}
-	}
-	return nil
-}
-
-func TestTokenFromIDAndSecret(t *testing.T) {
-	var tests = []struct {
-		bts      BootstrapTokenString
-		expected string
-	}{
-		{BootstrapTokenString{ID: "foo", Secret: "bar"}, "foo.bar"},
-		{BootstrapTokenString{ID: "abcdef", Secret: "abcdef0123456789"}, "abcdef.abcdef0123456789"},
-		{BootstrapTokenString{ID: "h", Secret: "b"}, "h.b"},
-	}
-	for _, rt := range tests {
-		t.Run(rt.bts.ID, func(t *testing.T) {
-			actual := rt.bts.String()
-			if actual != rt.expected {
-				t.Errorf(
-					"failed BootstrapTokenString.String():\n\texpected: %s\n\t  actual: %s",
-					rt.expected,
-					actual,
-				)
-			}
-		})
-	}
-}
-
-func TestNewBootstrapTokenString(t *testing.T) {
-	var tests = []struct {
-		token         string
-		expectedError bool
-		bts           *BootstrapTokenString
-	}{
-		{token: "", expectedError: true, bts: nil},
-		{token: ".", expectedError: true, bts: nil},
-		{token: "1234567890123456789012", expectedError: true, bts: nil},   // invalid parcel size
-		{token: "12345.1234567890123456", expectedError: true, bts: nil},   // invalid parcel size
-		{token: ".1234567890123456", expectedError: true, bts: nil},        // invalid parcel size
-		{token: "123456.", expectedError: true, bts: nil},                  // invalid parcel size
-		{token: "123456:1234567890.123456", expectedError: true, bts: nil}, // invalid separation
-		{token: "abcdef:1234567890123456", expectedError: true, bts: nil},  // invalid separation
-		{token: "Abcdef.1234567890123456", expectedError: true, bts: nil},  // invalid token id
-		{token: "123456.AABBCCDDEEFFGGHH", expectedError: true, bts: nil},  // invalid token secret
-		{token: "123456.AABBCCD-EEFFGGHH", expectedError: true, bts: nil},  // invalid character
-		{token: "abc*ef.1234567890123456", expectedError: true, bts: nil},  // invalid character
-		{token: "abcdef.1234567890123456", expectedError: false, bts: &BootstrapTokenString{ID: "abcdef", Secret: "1234567890123456"}},
-		{token: "123456.aabbccddeeffgghh", expectedError: false, bts: &BootstrapTokenString{ID: "123456", Secret: "aabbccddeeffgghh"}},
-		{token: "abcdef.abcdef0123456789", expectedError: false, bts: &BootstrapTokenString{ID: "abcdef", Secret: "abcdef0123456789"}},
-		{token: "123456.1234560123456789", expectedError: false, bts: &BootstrapTokenString{ID: "123456", Secret: "1234560123456789"}},
-	}
-	for _, rt := range tests {
-		t.Run(rt.token, func(t *testing.T) {
-			actual, err := NewBootstrapTokenString(rt.token)
-			if (err != nil) != rt.expectedError {
-				t.Errorf(
-					"failed NewBootstrapTokenString for the token %q\n\texpected error: %t\n\t  actual error: %v",
-					rt.token,
-					rt.expectedError,
-					err,
-				)
-			} else if !reflect.DeepEqual(actual, rt.bts) {
-				t.Errorf(
-					"failed NewBootstrapTokenString for the token %q\n\texpected: %v\n\t  actual: %v",
-					rt.token,
-					rt.bts,
-					actual,
-				)
-			}
-		})
-	}
-}
-
-func TestNewBootstrapTokenStringFromIDAndSecret(t *testing.T) {
-	var tests = []struct {
-		id, secret    string
-		expectedError bool
-		bts           *BootstrapTokenString
-	}{
-		{id: "", secret: "", expectedError: true, bts: nil},
-		{id: "1234567890123456789012", secret: "", expectedError: true, bts: nil}, // invalid parcel size
-		{id: "12345", secret: "1234567890123456", expectedError: true, bts: nil},  // invalid parcel size
-		{id: "", secret: "1234567890123456", expectedError: true, bts: nil},       // invalid parcel size
-		{id: "123456", secret: "", expectedError: true, bts: nil},                 // invalid parcel size
-		{id: "Abcdef", secret: "1234567890123456", expectedError: true, bts: nil}, // invalid token id
-		{id: "123456", secret: "AABBCCDDEEFFGGHH", expectedError: true, bts: nil}, // invalid token secret
-		{id: "123456", secret: "AABBCCD-EEFFGGHH", expectedError: true, bts: nil}, // invalid character
-		{id: "abc*ef", secret: "1234567890123456", expectedError: true, bts: nil}, // invalid character
-		{id: "abcdef", secret: "1234567890123456", expectedError: false, bts: &BootstrapTokenString{ID: "abcdef", Secret: "1234567890123456"}},
-		{id: "123456", secret: "aabbccddeeffgghh", expectedError: false, bts: &BootstrapTokenString{ID: "123456", Secret: "aabbccddeeffgghh"}},
-		{id: "abcdef", secret: "abcdef0123456789", expectedError: false, bts: &BootstrapTokenString{ID: "abcdef", Secret: "abcdef0123456789"}},
-		{id: "123456", secret: "1234560123456789", expectedError: false, bts: &BootstrapTokenString{ID: "123456", Secret: "1234560123456789"}},
-	}
-	for _, rt := range tests {
-		t.Run(rt.id, func(t *testing.T) {
-			actual, err := NewBootstrapTokenStringFromIDAndSecret(rt.id, rt.secret)
-			if (err != nil) != rt.expectedError {
-				t.Errorf(
-					"failed NewBootstrapTokenStringFromIDAndSecret for the token with id %q and secret %q\n\texpected error: %t\n\t  actual error: %v",
-					rt.id,
-					rt.secret,
-					rt.expectedError,
-					err,
-				)
-			} else if !reflect.DeepEqual(actual, rt.bts) {
-				t.Errorf(
-					"failed NewBootstrapTokenStringFromIDAndSecret for the token with id %q and secret %q\n\texpected: %v\n\t  actual: %v",
-					rt.id,
-					rt.secret,
-					rt.bts,
-					actual,
-				)
-			}
-		})
-	}
-}

cmd/kubeadm/app/apis/kubeadm/v1alpha3/conversion_test.go

-/*
-Copyright 2018 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 v1alpha3
-
-import (
-	"testing"
-
-	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-)
-
-func TestJoinConfigurationConversion(t *testing.T) {
-	testcases := map[string]struct {
-		old           *JoinConfiguration
-		expectedError bool
-	}{
-		"conversion succeeds": {
-			old:           &JoinConfiguration{},
-			expectedError: false,
-		},
-		"cluster name fails to be converted": {
-			old: &JoinConfiguration{
-				ClusterName: "kubernetes",
-			},
-			expectedError: true,
-		},
-		"feature gates fails to be converted": {
-			old: &JoinConfiguration{
-				FeatureGates: map[string]bool{
-					"someGate": true,
-				},
-			},
-			expectedError: true,
-		},
-	}
-	for name, tc := range testcases {
-		t.Run(name, func(t *testing.T) {
-			internal := &kubeadm.JoinConfiguration{}
-			err := Convert_v1alpha3_JoinConfiguration_To_kubeadm_JoinConfiguration(tc.old, internal, nil)
-			if (err != nil) != tc.expectedError {
-				t.Errorf("ImageToImageMeta returned unexpected error: %v, saw: %v", tc.expectedError, (err != nil))
-				return
-			}
-		})
-	}
-}
-
-func TestInitConfigurationConversion(t *testing.T) {
-	testcases := map[string]struct {
-		old         *InitConfiguration
-		expectedErr bool
-	}{
-		"conversion succeeds": {
-			old:         &InitConfiguration{},
-			expectedErr: false,
-		},
-		"feature gates fails to be converted": {
-			old: &InitConfiguration{
-				ClusterConfiguration: ClusterConfiguration{
-					AuditPolicyConfiguration: AuditPolicyConfiguration{
-						Path: "test",
-					},
-				},
-			},
-			expectedErr: true,
-		},
-	}
-	for name, tc := range testcases {
-		t.Run(name, func(t *testing.T) {
-			internal := &kubeadm.InitConfiguration{}
-			err := Convert_v1alpha3_InitConfiguration_To_kubeadm_InitConfiguration(tc.old, internal, nil)
-			if (err != nil) != tc.expectedErr {
-				t.Errorf("no error was expected but '%s' was found", err)
-			}
-		})
-	}
-}
-
-func TestConvertToUseHyperKubeImage(t *testing.T) {
-	tests := []struct {
-		desc              string
-		in                *ClusterConfiguration
-		useHyperKubeImage bool
-		expectedErr       bool
-	}{
-		{
-			desc:              "unset UnifiedControlPlaneImage sets UseHyperKubeImage to false",
-			in:                &ClusterConfiguration{},
-			useHyperKubeImage: false,
-			expectedErr:       false,
-		},
-		{
-			desc: "matching UnifiedControlPlaneImage sets UseHyperKubeImage to true",
-			in: &ClusterConfiguration{
-				ImageRepository:          "k8s.gcr.io",
-				KubernetesVersion:        "v1.12.2",
-				UnifiedControlPlaneImage: "k8s.gcr.io/hyperkube:v1.12.2",
-			},
-			useHyperKubeImage: true,
-			expectedErr:       false,
-		},
-		{
-			desc: "mismatching UnifiedControlPlaneImage tag causes an error",
-			in: &ClusterConfiguration{
-				ImageRepository:          "k8s.gcr.io",
-				KubernetesVersion:        "v1.12.0",
-				UnifiedControlPlaneImage: "k8s.gcr.io/hyperkube:v1.12.2",
-			},
-			expectedErr: true,
-		},
-		{
-			desc: "mismatching UnifiedControlPlaneImage repo causes an error",
-			in: &ClusterConfiguration{
-				ImageRepository:          "my.repo",
-				KubernetesVersion:        "v1.12.2",
-				UnifiedControlPlaneImage: "k8s.gcr.io/hyperkube:v1.12.2",
-			},
-			expectedErr: true,
-		},
-		{
-			desc: "mismatching UnifiedControlPlaneImage image name causes an error",
-			in: &ClusterConfiguration{
-				ImageRepository:          "k8s.gcr.io",
-				KubernetesVersion:        "v1.12.2",
-				UnifiedControlPlaneImage: "k8s.gcr.io/otherimage:v1.12.2",
-			},
-			expectedErr: true,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.desc, func(t *testing.T) {
-			out := &kubeadm.ClusterConfiguration{}
-			err := Convert_v1alpha3_UnifiedControlPlaneImage_To_kubeadm_UseHyperKubeImage(test.in, out)
-			if test.expectedErr {
-				if err == nil {
-					t.Fatalf("unexpected success, UseHyperKubeImage: %t", out.UseHyperKubeImage)
-				}
-			} else {
-				if err != nil {
-					t.Fatalf("unexpected failure: %v", err)
-				}
-				if out.UseHyperKubeImage != test.useHyperKubeImage {
-					t.Fatalf("mismatching result from conversion:\n\tExpected: %t\n\tReceived: %t", test.useHyperKubeImage, out.UseHyperKubeImage)
-				}
-			}
-		})
-	}
-}
-
-func TestEtcdImageToImageMeta(t *testing.T) {
-	tests := []struct {
-		name              string
-		image             string
-		expectedImageMeta kubeadm.ImageMeta
-		expectedError     bool
-	}{
-		{
-			name:  "Empty image -> Empty image meta",
-			image: "",
-			expectedImageMeta: kubeadm.ImageMeta{
-				ImageRepository: "",
-				ImageTag:        "",
-			},
-		},
-		{
-			name:  "image with tag and repository",
-			image: "custom.repo/etcd:custom.tag",
-			expectedImageMeta: kubeadm.ImageMeta{
-				ImageRepository: "custom.repo",
-				ImageTag:        "custom.tag",
-			},
-		},
-		{
-			name:          "image with custom imageName",
-			image:         "real.repo/custom-image-name-for-etcd:real.tag",
-			expectedError: true,
-		},
-		{
-			name:          "image without repository",
-			image:         "etcd:real.tag",
-			expectedError: true,
-		},
-		{
-			name:          "image without tag",
-			image:         "real.repo/etcd",
-			expectedError: true,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			ret, err := etcdImageToImageMeta(test.image)
-
-			if (err != nil) != test.expectedError {
-				t.Errorf("etcdImageToImageMeta returned unexpected error: %v, saw: %v", test.expectedError, (err != nil))
-				return
-			}
-
-			if ret != test.expectedImageMeta {
-				t.Errorf("etcdImageToImageMeta returned unexpected ImageMeta: %v, saw: %v", test.expectedImageMeta, ret)
-			}
-		})
-	}
-}

cmd/kubeadm/app/apis/kubeadm/v1alpha3/defaults.go

-/*
-Copyright 2018 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 v1alpha3
-
-import (
-	"net/url"
-	"time"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
-)
-
-const (
-	// DefaultServiceDNSDomain defines default cluster-internal domain name for Services and Pods
-	DefaultServiceDNSDomain = "cluster.local"
-	// DefaultServicesSubnet defines default service subnet range
-	DefaultServicesSubnet = "10.96.0.0/12"
-	// DefaultClusterDNSIP defines default DNS IP
-	DefaultClusterDNSIP = "10.96.0.10"
-	// DefaultKubernetesVersion defines default kubernetes version
-	DefaultKubernetesVersion = "stable-1"
-	// DefaultAPIBindPort defines default API port
-	DefaultAPIBindPort = 6443
-	// DefaultCertificatesDir defines default certificate directory
-	DefaultCertificatesDir = "/etc/kubernetes/pki"
-	// DefaultImageRepository defines default image registry
-	DefaultImageRepository = "k8s.gcr.io"
-	// DefaultManifestsDir defines default manifests directory
-	DefaultManifestsDir = "/etc/kubernetes/manifests"
-	// DefaultClusterName defines the default cluster name
-	DefaultClusterName = "kubernetes"
-
-	// DefaultEtcdDataDir defines default location of etcd where static pods will save data to
-	DefaultEtcdDataDir = "/var/lib/etcd"
-	// DefaultProxyBindAddressv4 is the default bind address when the advertise address is v4
-	DefaultProxyBindAddressv4 = "0.0.0.0"
-	// DefaultProxyBindAddressv6 is the default bind address when the advertise address is v6
-	DefaultProxyBindAddressv6 = "::"
-	// DefaultDiscoveryTimeout specifies the default discovery timeout for kubeadm (used unless one is specified in the JoinConfiguration)
-	DefaultDiscoveryTimeout = 5 * time.Minute
-)
-
-var (
-	// DefaultAuditPolicyLogMaxAge is defined as a var so its address can be taken
-	// It is the number of days to store audit logs
-	DefaultAuditPolicyLogMaxAge = int32(2)
-)
-
-func addDefaultingFuncs(scheme *runtime.Scheme) error {
-	return RegisterDefaults(scheme)
-}
-
-// SetDefaults_InitConfiguration assigns default values for the InitConfiguration
-func SetDefaults_InitConfiguration(obj *InitConfiguration) {
-	SetDefaults_ClusterConfiguration(&obj.ClusterConfiguration)
-	SetDefaults_BootstrapTokens(obj)
-	SetDefaults_APIEndpoint(&obj.APIEndpoint)
-}
-
-// SetDefaults_ClusterConfiguration assigns default values for the ClusterConfiguration
-func SetDefaults_ClusterConfiguration(obj *ClusterConfiguration) {
-	if obj.KubernetesVersion == "" {
-		obj.KubernetesVersion = DefaultKubernetesVersion
-	}
-
-	if obj.Networking.ServiceSubnet == "" {
-		obj.Networking.ServiceSubnet = DefaultServicesSubnet
-	}
-
-	if obj.Networking.DNSDomain == "" {
-		obj.Networking.DNSDomain = DefaultServiceDNSDomain
-	}
-
-	if obj.CertificatesDir == "" {
-		obj.CertificatesDir = DefaultCertificatesDir
-	}
-
-	if obj.ImageRepository == "" {
-		obj.ImageRepository = DefaultImageRepository
-	}
-
-	if obj.ClusterName == "" {
-		obj.ClusterName = DefaultClusterName
-	}
-
-	SetDefaults_Etcd(obj)
-	SetDefaults_AuditPolicyConfiguration(obj)
-}
-
-// SetDefaults_Etcd assigns default values for the Proxy
-func SetDefaults_Etcd(obj *ClusterConfiguration) {
-	if obj.Etcd.External == nil && obj.Etcd.Local == nil {
-		obj.Etcd.Local = &LocalEtcd{}
-	}
-	if obj.Etcd.Local != nil {
-		if obj.Etcd.Local.DataDir == "" {
-			obj.Etcd.Local.DataDir = DefaultEtcdDataDir
-		}
-	}
-}
-
-// SetDefaults_JoinConfiguration assigns default values to a regular node
-func SetDefaults_JoinConfiguration(obj *JoinConfiguration) {
-	if obj.CACertPath == "" {
-		obj.CACertPath = DefaultCACertPath
-	}
-	if len(obj.TLSBootstrapToken) == 0 {
-		obj.TLSBootstrapToken = obj.Token
-	}
-	if len(obj.DiscoveryToken) == 0 && len(obj.DiscoveryFile) == 0 {
-		obj.DiscoveryToken = obj.Token
-	}
-	// Make sure file URLs become paths
-	if len(obj.DiscoveryFile) != 0 {
-		u, err := url.Parse(obj.DiscoveryFile)
-		if err == nil && u.Scheme == "file" {
-			obj.DiscoveryFile = u.Path
-		}
-	}
-	if obj.DiscoveryTimeout == nil {
-		obj.DiscoveryTimeout = &metav1.Duration{
-			Duration: DefaultDiscoveryTimeout,
-		}
-	}
-
-	SetDefaults_APIEndpoint(&obj.APIEndpoint)
-}
-
-// SetDefaults_AuditPolicyConfiguration sets default values for the AuditPolicyConfiguration
-func SetDefaults_AuditPolicyConfiguration(obj *ClusterConfiguration) {
-	if obj.AuditPolicyConfiguration.LogDir == "" {
-		obj.AuditPolicyConfiguration.LogDir = constants.StaticPodAuditPolicyLogDir
-	}
-	if obj.AuditPolicyConfiguration.LogMaxAge == nil {
-		obj.AuditPolicyConfiguration.LogMaxAge = &DefaultAuditPolicyLogMaxAge
-	}
-}
-
-// SetDefaults_BootstrapTokens sets the defaults for the .BootstrapTokens field
-// If the slice is empty, it's defaulted with one token. Otherwise it just loops
-// through the slice and sets the defaults for the omitempty fields that are TTL,
-// Usages and Groups. Token is NOT defaulted with a random one in the API defaulting
-// layer, but set to a random value later at runtime if not set before.
-func SetDefaults_BootstrapTokens(obj *InitConfiguration) {
-
-	if obj.BootstrapTokens == nil || len(obj.BootstrapTokens) == 0 {
-		obj.BootstrapTokens = []BootstrapToken{{}}
-	}
-
-	for i := range obj.BootstrapTokens {
-		SetDefaults_BootstrapToken(&obj.BootstrapTokens[i])
-	}
-}
-
-// SetDefaults_BootstrapToken sets the defaults for an individual Bootstrap Token
-func SetDefaults_BootstrapToken(bt *BootstrapToken) {
-	if bt.TTL == nil {
-		bt.TTL = &metav1.Duration{
-			Duration: constants.DefaultTokenDuration,
-		}
-	}
-	if len(bt.Usages) == 0 {
-		bt.Usages = constants.DefaultTokenUsages
-	}
-
-	if len(bt.Groups) == 0 {
-		bt.Groups = constants.DefaultTokenGroups
-	}
-}
-
-// SetDefaults_APIEndpoint sets the defaults for the API server instance deployed on a node.
-func SetDefaults_APIEndpoint(obj *APIEndpoint) {
-	if obj.BindPort == 0 {
-		obj.BindPort = DefaultAPIBindPort
-	}
-}

cmd/kubeadm/app/apis/kubeadm/v1alpha3/defaults_unix.go

-// +build !windows
-
-/*
-Copyright 2018 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 v1alpha3
-
-const (
-	// DefaultCACertPath defines default location of CA certificate on Linux
-	DefaultCACertPath = "/etc/kubernetes/pki/ca.crt"
-)

cmd/kubeadm/app/apis/kubeadm/v1alpha3/defaults_windows.go

-// +build windows
-
-/*
-Copyright 2018 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 v1alpha3
-
-const (
-	// DefaultCACertPath defines default location of CA certificate on Windows
-	DefaultCACertPath = "C:/etc/kubernetes/pki/ca.crt"
-)

cmd/kubeadm/app/apis/kubeadm/v1alpha3/register.go

-/*
-Copyright 2018 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 v1alpha3
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-// GroupName is the group name use in this package
-const GroupName = "kubeadm.k8s.io"
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha3"}
-
-var (
-	// TODO: move SchemeBuilder with zz_generated.deepcopy.go to k8s.io/api.
-	// localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes.
-
-	// SchemeBuilder points to a list of functions added to Scheme.
-	SchemeBuilder      runtime.SchemeBuilder
-	localSchemeBuilder = &SchemeBuilder
-	// AddToScheme applies all the stored functions to the scheme.
-	AddToScheme = localSchemeBuilder.AddToScheme
-)
-
-func init() {
-	// We only register manually written functions here. The registration of the
-	// generated functions takes place in the generated files. The separation
-	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register(addKnownTypes, addDefaultingFuncs)
-}
-
-// Kind takes an unqualified kind and returns a Group qualified GroupKind
-func Kind(kind string) schema.GroupKind {
-	return SchemeGroupVersion.WithKind(kind).GroupKind()
-}
-
-// Resource takes an unqualified resource and returns a Group qualified GroupResource
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}
-
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&InitConfiguration{},
-		&ClusterConfiguration{},
-		&ClusterStatus{},
-		&JoinConfiguration{},
-	)
-	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
-	return nil
-}

cmd/kubeadm/app/apis/kubeadm/v1alpha3/zz_generated.defaults.go

-// +build !ignore_autogenerated
-
-/*
-Copyright 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.
-*/
-
-// Code generated by defaulter-gen. DO NOT EDIT.
-
-package v1alpha3
-
-import (
-	runtime "k8s.io/apimachinery/pkg/runtime"
-)
-
-// RegisterDefaults adds defaulters functions to the given scheme.
-// Public to allow building arbitrary schemes.
-// All generated defaulters are covering - they call all nested defaulters.
-func RegisterDefaults(scheme *runtime.Scheme) error {
-	scheme.AddTypeDefaultingFunc(&ClusterConfiguration{}, func(obj interface{}) { SetObjectDefaults_ClusterConfiguration(obj.(*ClusterConfiguration)) })
-	scheme.AddTypeDefaultingFunc(&ClusterStatus{}, func(obj interface{}) { SetObjectDefaults_ClusterStatus(obj.(*ClusterStatus)) })
-	scheme.AddTypeDefaultingFunc(&InitConfiguration{}, func(obj interface{}) { SetObjectDefaults_InitConfiguration(obj.(*InitConfiguration)) })
-	scheme.AddTypeDefaultingFunc(&JoinConfiguration{}, func(obj interface{}) { SetObjectDefaults_JoinConfiguration(obj.(*JoinConfiguration)) })
-	return nil
-}
-
-func SetObjectDefaults_ClusterConfiguration(in *ClusterConfiguration) {
-	SetDefaults_ClusterConfiguration(in)
-}
-
-func SetObjectDefaults_ClusterStatus(in *ClusterStatus) {
-}
-
-func SetObjectDefaults_InitConfiguration(in *InitConfiguration) {
-	SetDefaults_InitConfiguration(in)
-	SetObjectDefaults_ClusterConfiguration(&in.ClusterConfiguration)
-	for i := range in.BootstrapTokens {
-		a := &in.BootstrapTokens[i]
-		SetDefaults_BootstrapToken(a)
-	}
-	SetDefaults_APIEndpoint(&in.APIEndpoint)
-}
-
-func SetObjectDefaults_JoinConfiguration(in *JoinConfiguration) {
-	SetDefaults_JoinConfiguration(in)
-	SetDefaults_APIEndpoint(&in.APIEndpoint)
-}

cmd/kubeadm/app/cmd/BUILD

@@ -22,7 +22,6 @@ go_library(
     deps = [
         "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
         "//cmd/kubeadm/app/apis/kubeadm/scheme:go_default_library",
-        "//cmd/kubeadm/app/apis/kubeadm/v1alpha3:go_default_library",
         "//cmd/kubeadm/app/apis/kubeadm/v1beta1:go_default_library",
         "//cmd/kubeadm/app/apis/kubeadm/validation:go_default_library",
         "//cmd/kubeadm/app/cmd/alpha:go_default_library",

cmd/kubeadm/app/cmd/config.go

@@ -33,7 +33,6 @@ import (
 	clientset "k8s.io/client-go/kubernetes"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
-	kubeadmapiv1alpha3 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha3"
 	kubeadmapiv1beta1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta1"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	phaseutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases"
@@ -231,7 +230,6 @@ func NewCmdConfigMigrate(out io.Writer) *cobra.Command {
 			locally in the CLI tool without ever touching anything in the cluster.
 			In this version of kubeadm, the following API versions are supported:
 			- %s
-			- %s
 
 			Further, kubeadm can only write out config of version %q, but read both types.
 			So regardless of what version you pass to the --old-config parameter here, the API object will be
@@ -240,7 +238,7 @@ func NewCmdConfigMigrate(out io.Writer) *cobra.Command {
 
 			In other words, the output of this command is what kubeadm actually would read internally if you
 			submitted this file to "kubeadm init"
-		`), kubeadmapiv1alpha3.SchemeGroupVersion.String(), kubeadmapiv1beta1.SchemeGroupVersion.String(), kubeadmapiv1beta1.SchemeGroupVersion.String()),
+		`), kubeadmapiv1beta1.SchemeGroupVersion, kubeadmapiv1beta1.SchemeGroupVersion),
 		Run: func(cmd *cobra.Command, args []string) {
 			if len(oldCfgPath) == 0 {
 				kubeadmutil.CheckErr(errors.New("The --old-config flag is mandatory"))

cmd/kubeadm/app/cmd/config_test.go

@@ -258,8 +258,8 @@ func TestImagesPull(t *testing.T) {
 
 func TestMigrate(t *testing.T) {
 	cfg := []byte(dedent.Dedent(`
-		# This is intentionally testing an old API version and the old kind naming and making sure the output is correct
-		apiVersion: kubeadm.k8s.io/v1alpha3
+		# This is intentionally testing an old API version. Sometimes this may be the latest version (if no old configs are supported).
+		apiVersion: kubeadm.k8s.io/v1beta1
 		kind: InitConfiguration
 	`))
 	configFile, cleanup := tempConfig(t, cfg)

cmd/kubeadm/app/util/config/cluster_test.go

@@ -58,27 +58,6 @@ apiEndpoints:
 apiVersion: kubeadm.k8s.io/v1beta1
 kind: ClusterStatus
 `),
-	"InitConfiguration_v1alpha3": []byte(`
-apiVersion: kubeadm.k8s.io/v1alpha3
-kind: InitConfiguration
-`),
-	"ClusterConfiguration_v1alpha3": []byte(`
-apiVersion: kubeadm.k8s.io/v1alpha3
-kind: ClusterConfiguration
-kubernetesVersion: ` + k8sVersionString + `
-`),
-	"ClusterStatus_v1alpha3": []byte(`
-apiVersion: kubeadm.k8s.io/v1alpha3
-kind: ClusterStatus
-apiEndpoints: 
-  ` + nodeName + `: 
-    advertiseAddress: 1.2.3.4
-    bindPort: 1234
-`),
-	"ClusterStatus_v1alpha3_Without_APIEndpoints": []byte(`
-apiVersion: kubeadm.k8s.io/v1alpha3
-kind: ClusterStatus
-`),
 	"Kube-proxy_componentconfig": []byte(`
 apiVersion: kubeproxy.config.k8s.io/v1alpha1
 kind: KubeProxyConfiguration
@@ -356,33 +335,6 @@ func TestGetAPIEndpoint(t *testing.T) {
 			},
 			expectedError: true,
 		},
-		{
-			name: "valid v1alpha3",
-			configMap: fakeConfigMap{
-				name: kubeadmconstants.KubeadmConfigConfigMap, // ClusterConfiguration from kubeadm-config.
-				data: map[string]string{
-					kubeadmconstants.ClusterStatusConfigMapKey: string(cfgFiles["ClusterStatus_v1alpha3"]),
-				},
-			},
-		},
-		{
-			name: "invalid v1alpha3 - No ClusterStatus in kubeadm-config ConfigMap",
-			configMap: fakeConfigMap{
-				name: kubeadmconstants.KubeadmConfigConfigMap, // ClusterConfiguration from kubeadm-config.
-				data: map[string]string{},
-			},
-			expectedError: true,
-		},
-		{
-			name: "invalid v1alpha3 - ClusterStatus without APIEndopoints",
-			configMap: fakeConfigMap{
-				name: kubeadmconstants.KubeadmConfigConfigMap, // ClusterConfiguration from kubeadm-config.
-				data: map[string]string{
-					kubeadmconstants.ClusterStatusConfigMapKey: string(cfgFiles["ClusterStatus_v1alpha3_Without_APIEndpoints"]),
-				},
-			},
-			expectedError: true,
-		},
 	}
 
 	for _, rt := range tests {
@@ -579,66 +531,6 @@ func TestGetInitConfigurationFromCluster(t *testing.T) {
 			},
 			newControlPlane: true,
 		},
-		{
-			name: "valid v1alpha3 - new control plane == false", // InitConfiguration composed with data from different places, with also node specific information from ClusterStatus and node
-			configMaps: []fakeConfigMap{
-				{
-					name: kubeadmconstants.KubeadmConfigConfigMap, // ClusterConfiguration from kubeadm-config.
-					data: map[string]string{
-						kubeadmconstants.ClusterConfigurationConfigMapKey: string(cfgFiles["ClusterConfiguration_v1alpha3"]),
-						kubeadmconstants.ClusterStatusConfigMapKey:        string(cfgFiles["ClusterStatus_v1alpha3"]),
-					},
-				},
-				{
-					name: kubeadmconstants.KubeProxyConfigMap, // Kube-proxy component config from corresponding ConfigMap.
-					data: map[string]string{
-						kubeadmconstants.KubeProxyConfigMapKey: string(cfgFiles["Kube-proxy_componentconfig"]),
-					},
-				},
-				{
-					name: kubeadmconstants.GetKubeletConfigMapName(k8sVersion), // Kubelet component config from corresponding ConfigMap.
-					data: map[string]string{
-						kubeadmconstants.KubeletBaseConfigurationConfigMapKey: string(cfgFiles["Kubelet_componentconfig"]),
-					},
-				},
-			},
-			fileContents: kubeletConfFiles["configWithEmbeddedCert"],
-			node: &v1.Node{
-				ObjectMeta: metav1.ObjectMeta{
-					Name: nodeName,
-					Annotations: map[string]string{
-						kubeadmconstants.AnnotationKubeadmCRISocket: "myCRIsocket",
-					},
-				},
-				Spec: v1.NodeSpec{
-					Taints: []v1.Taint{kubeadmconstants.ControlPlaneTaint},
-				},
-			},
-		},
-		{
-			name: "valid v1alpha3 - new control plane == true", // InitConfiguration composed with data from different places, without node specific information
-			configMaps: []fakeConfigMap{
-				{
-					name: kubeadmconstants.KubeadmConfigConfigMap, // ClusterConfiguration from kubeadm-config.
-					data: map[string]string{
-						kubeadmconstants.ClusterConfigurationConfigMapKey: string(cfgFiles["ClusterConfiguration_v1alpha3"]),
-					},
-				},
-				{
-					name: kubeadmconstants.KubeProxyConfigMap, // Kube-proxy component config from corresponding ConfigMap.
-					data: map[string]string{
-						kubeadmconstants.KubeProxyConfigMapKey: string(cfgFiles["Kube-proxy_componentconfig"]),
-					},
-				},
-				{
-					name: kubeadmconstants.GetKubeletConfigMapName(k8sVersion), // Kubelet component config from corresponding ConfigMap.
-					data: map[string]string{
-						kubeadmconstants.KubeletBaseConfigurationConfigMapKey: string(cfgFiles["Kubelet_componentconfig"]),
-					},
-				},
-			},
-			newControlPlane: true,
-		},
 	}
 
 	for _, rt := range tests {
@@ -723,18 +615,6 @@ func TestGetGetClusterStatus(t *testing.T) {
 			expectedEndpoints: 1,
 		},
 		{
-			name: "valid v1alpha3",
-			configMaps: []fakeConfigMap{
-				{
-					name: kubeadmconstants.KubeadmConfigConfigMap,
-					data: map[string]string{
-						kubeadmconstants.ClusterStatusConfigMapKey: string(cfgFiles["ClusterStatus_v1alpha3"]),
-					},
-				},
-			},
-			expectedEndpoints: 1,
-		},
-		{
 			name: "invalid missing ClusterStatusConfigMapKey in the config map",
 			configMaps: []fakeConfigMap{
 				{

cmd/kubeadm/app/util/config/common.go

@@ -57,15 +57,15 @@ func validateSupportedVersion(gv schema.GroupVersion, allowDeprecated bool) erro
 	// v1.12: v1alpha2 read-only, writes only v1alpha3 config. Errors if the user tries to use v1alpha1
 	// v1.13: v1alpha3 read-only, writes only v1beta1 config. Errors if the user tries to use v1alpha1 or v1alpha2
 	// v1.14: v1alpha3 convert only, writes only v1beta1 config. Errors if the user tries to use v1alpha1 or v1alpha2
+	// v1.15: only v1beta1 config. Errors if the user tries to use v1alpha1, v1alpha2 or v1alpha3
 	oldKnownAPIVersions := map[string]string{
 		"kubeadm.k8s.io/v1alpha1": "v1.11",
 		"kubeadm.k8s.io/v1alpha2": "v1.12",
+		"kubeadm.k8s.io/v1alpha3": "v1.14",
 	}
 
 	// Deprecated API versions are supported by us, but can only be used for migration.
-	deprecatedAPIVersions := map[string]struct{}{
-		"kubeadm.k8s.io/v1alpha3": {}, // Can be migrated with kubeadm 1.13+
-	}
+	deprecatedAPIVersions := map[string]struct{}{}
 
 	gvString := gv.String()
 

cmd/kubeadm/app/util/config/common_test.go

@@ -63,6 +63,7 @@ func TestValidateSupportedVersion(t *testing.T) {
 				Version: "v1alpha3",
 			},
 			allowDeprecated: true,
+			expectedErr:     true,
 		},
 		{
 			gv: schema.GroupVersion{
@@ -206,14 +207,14 @@ func TestMigrateOldConfigFromFile(t *testing.T) {
 		{
 			desc: "bad config produces error",
 			oldCfg: dedent.Dedent(`
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			`),
 			expectErr: true,
 		},
 		{
 			desc: "InitConfiguration only gets migrated",
 			oldCfg: dedent.Dedent(`
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: InitConfiguration
 			`),
 			expectedKinds: []string{
@@ -225,7 +226,7 @@ func TestMigrateOldConfigFromFile(t *testing.T) {
 		{
 			desc: "ClusterConfiguration only gets migrated",
 			oldCfg: dedent.Dedent(`
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: ClusterConfiguration
 			`),
 			expectedKinds: []string{
@@ -237,12 +238,13 @@ func TestMigrateOldConfigFromFile(t *testing.T) {
 		{
 			desc: "JoinConfiguration only gets migrated",
 			oldCfg: dedent.Dedent(`
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: JoinConfiguration
-			token: abcdef.0123456789abcdef
-			discoveryTokenAPIServers:
-			- kube-apiserver:6443
-			discoveryTokenUnsafeSkipCAVerification: true
+			discovery:
+			  bootstrapToken:
+			    token: abcdef.0123456789abcdef
+			    apiServerEndpoint: kube-apiserver:6443
+			    unsafeSkipCAVerification: true
 			`),
 			expectedKinds: []string{
 				constants.JoinConfigurationKind,
@@ -252,10 +254,10 @@ func TestMigrateOldConfigFromFile(t *testing.T) {
 		{
 			desc: "Init + Cluster Configurations are migrated",
 			oldCfg: dedent.Dedent(`
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: InitConfiguration
 			---
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: ClusterConfiguration
 			`),
 			expectedKinds: []string{
@@ -267,15 +269,16 @@ func TestMigrateOldConfigFromFile(t *testing.T) {
 		{
 			desc: "Init + Join Configurations are migrated",
 			oldCfg: dedent.Dedent(`
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: InitConfiguration
 			---
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: JoinConfiguration
-			token: abcdef.0123456789abcdef
-			discoveryTokenAPIServers:
-			- kube-apiserver:6443
-			discoveryTokenUnsafeSkipCAVerification: true
+			discovery:
+			  bootstrapToken:
+			    token: abcdef.0123456789abcdef
+			    apiServerEndpoint: kube-apiserver:6443
+			    unsafeSkipCAVerification: true
 			`),
 			expectedKinds: []string{
 				constants.InitConfigurationKind,
@@ -287,15 +290,16 @@ func TestMigrateOldConfigFromFile(t *testing.T) {
 		{
 			desc: "Cluster + Join Configurations are migrated",
 			oldCfg: dedent.Dedent(`
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: ClusterConfiguration
 			---
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: JoinConfiguration
-			token: abcdef.0123456789abcdef
-			discoveryTokenAPIServers:
-			- kube-apiserver:6443
-			discoveryTokenUnsafeSkipCAVerification: true
+			discovery:
+			  bootstrapToken:
+			    token: abcdef.0123456789abcdef
+			    apiServerEndpoint: kube-apiserver:6443
+			    unsafeSkipCAVerification: true
 			`),
 			expectedKinds: []string{
 				constants.InitConfigurationKind,
@@ -307,18 +311,19 @@ func TestMigrateOldConfigFromFile(t *testing.T) {
 		{
 			desc: "Init + Cluster + Join Configurations are migrated",
 			oldCfg: dedent.Dedent(`
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: InitConfiguration
 			---
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: ClusterConfiguration
 			---
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: JoinConfiguration
-			token: abcdef.0123456789abcdef
-			discoveryTokenAPIServers:
-			- kube-apiserver:6443
-			discoveryTokenUnsafeSkipCAVerification: true
+			discovery:
+			  bootstrapToken:
+			    token: abcdef.0123456789abcdef
+			    apiServerEndpoint: kube-apiserver:6443
+			    unsafeSkipCAVerification: true
 			`),
 			expectedKinds: []string{
 				constants.InitConfigurationKind,
@@ -330,18 +335,19 @@ func TestMigrateOldConfigFromFile(t *testing.T) {
 		{
 			desc: "component configs are not migrated",
 			oldCfg: dedent.Dedent(`
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: InitConfiguration
 			---
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: ClusterConfiguration
 			---
-			apiVersion: kubeadm.k8s.io/v1alpha3
+			apiVersion: kubeadm.k8s.io/v1beta1
 			kind: JoinConfiguration
-			token: abcdef.0123456789abcdef
-			discoveryTokenAPIServers:
-			- kube-apiserver:6443
-			discoveryTokenUnsafeSkipCAVerification: true
+			discovery:
+			  bootstrapToken:
+			    token: abcdef.0123456789abcdef
+			    apiServerEndpoint: kube-apiserver:6443
+			    unsafeSkipCAVerification: true
 			---
 			apiVersion: kubeproxy.config.k8s.io/v1alpha1
 			kind: KubeProxyConfiguration

cmd/kubeadm/app/util/config/initconfiguration_test.go

@@ -30,8 +30,6 @@ import (
 )
 
 const (
-	controlPlaneV1alpha3YAML          = "testdata/conversion/controlplane/v1alpha3.yaml"
-	controlPlaneV1alpha3YAMLNonLinux  = "testdata/conversion/controlplane/v1alpha3_non_linux.yaml"
 	controlPlaneV1beta1YAML           = "testdata/conversion/controlplane/v1beta1.yaml"
 	controlPlaneV1beta1YAMLNonLinux   = "testdata/conversion/controlplane/v1beta1_non_linux.yaml"
 	controlPlaneInternalYAML          = "testdata/conversion/controlplane/internal.yaml"
@@ -86,26 +84,6 @@ func TestLoadInitConfigurationFromFile(t *testing.T) {
 				cfgFiles["Kubelet_componentconfig"],
 			}, []byte(constants.YAMLDocumentSeparator)),
 		},
-		{
-			name:         "v1alpha3.partial1",
-			fileContents: cfgFiles["InitConfiguration_v1alpha3"],
-			expectErr:    true,
-		},
-		{
-			name:         "v1alpha3.partial2",
-			fileContents: cfgFiles["ClusterConfiguration_v1alpha3"],
-			expectErr:    true,
-		},
-		{
-			name: "v1alpha3.full",
-			fileContents: bytes.Join([][]byte{
-				cfgFiles["InitConfiguration_v1alpha3"],
-				cfgFiles["ClusterConfiguration_v1alpha3"],
-				cfgFiles["Kube-proxy_componentconfig"],
-				cfgFiles["Kubelet_componentconfig"],
-			}, []byte(constants.YAMLDocumentSeparator)),
-			expectErr: true,
-		},
 	}
 
 	for _, rt := range tests {
@@ -138,12 +116,10 @@ func TestLoadInitConfigurationFromFile(t *testing.T) {
 
 /*
 func TestInitConfigurationMarshallingFromFile(t *testing.T) {
-	controlPlaneV1alpha3YAMLAbstracted := controlPlaneV1alpha3YAML
 	controlPlaneV1beta1YAMLAbstracted := controlPlaneV1beta1YAML
 	controlPlaneInternalYAMLAbstracted := controlPlaneInternalYAML
 	controlPlaneDefaultedYAMLAbstracted := controlPlaneDefaultedYAML
 	if runtime.GOOS != "linux" {
-		controlPlaneV1alpha3YAMLAbstracted = controlPlaneV1alpha3YAMLNonLinux
 		controlPlaneV1beta1YAMLAbstracted = controlPlaneV1beta1YAMLNonLinux
 		controlPlaneInternalYAMLAbstracted = controlPlaneInternalYAMLNonLinux
 		controlPlaneDefaultedYAMLAbstracted = controlPlaneDefaultedYAMLNonLinux
@@ -156,11 +132,6 @@ func TestInitConfigurationMarshallingFromFile(t *testing.T) {
 	}{
 		// These tests are reading one file, loading it using LoadInitConfigurationFromFile that all of kubeadm is using for unmarshal of our API types,
 		// and then marshals the internal object to the expected groupVersion
-		{ // v1alpha3 -> internal
-			name:        "v1alpha3IsDeprecated",
-			in:          controlPlaneV1alpha3YAMLAbstracted,
-			expectedErr: true,
-		},
 		//{ // v1beta1 -> internal NB. test commented after changes required for upgrading to go v1.12
 		//	name:         "v1beta1ToInternal",
 		//	in:           controlPlaneV1beta1YAMLAbstracted,

cmd/kubeadm/app/util/config/joinconfiguration_test.go

@@ -29,7 +29,6 @@ import (
 )
 
 const (
-	nodeV1alpha3YAML   = "testdata/conversion/node/v1alpha3.yaml"
 	nodeV1beta1YAML    = "testdata/conversion/node/v1beta1.yaml"
 	nodeInternalYAML   = "testdata/conversion/node/internal.yaml"
 	nodeIncompleteYAML = "testdata/defaulting/node/incomplete.yaml"
@@ -45,11 +44,6 @@ func TestLoadJoinConfigurationFromFile(t *testing.T) {
 	}{
 		// These tests are reading one file, loading it using LoadJoinConfigurationFromFile that all of kubeadm is using for unmarshal of our API types,
 		// and then marshals the internal object to the expected groupVersion
-		{ // v1alpha3 -> internal
-			name:        "v1alpha3IsDeprecated",
-			in:          nodeV1alpha3YAML,
-			expectedErr: true,
-		},
 		{ // v1beta1 -> internal
 			name:         "v1beta1ToInternal",
 			in:           nodeV1beta1YAML,

cmd/kubeadm/app/util/config/strict/BUILD

@@ -21,7 +21,6 @@ go_test(
     data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     deps = [
-        "//cmd/kubeadm/app/apis/kubeadm/v1alpha3:go_default_library",
         "//cmd/kubeadm/app/apis/kubeadm/v1beta1:go_default_library",
         "//cmd/kubeadm/app/componentconfigs:go_default_library",
         "//cmd/kubeadm/app/constants:go_default_library",

cmd/kubeadm/app/util/config/strict/strict_test.go

@@ -24,7 +24,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	kubeproxyconfigv1alpha1 "k8s.io/kube-proxy/config/v1alpha1"
 	kubeletconfigv1beta1 "k8s.io/kubelet/config/v1beta1"
-	kubeadmapiv1alpha3 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha3"
 	kubeadmapiv1beta1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta1"
 	"k8s.io/kubernetes/cmd/kubeadm/app/componentconfigs"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
@@ -49,12 +48,6 @@ func TestVerifyUnmarshalStrict(t *testing.T) {
 			expectedError: true,
 		},
 		{
-			fileName:      "invalid_duplicate_field_initcfg.yaml",
-			kind:          constants.InitConfigurationKind,
-			groupVersion:  kubeadmapiv1alpha3.SchemeGroupVersion,
-			expectedError: true,
-		},
-		{
 			fileName:      "invalid_duplicate_field_joincfg.yaml",
 			kind:          constants.JoinConfigurationKind,
 			groupVersion:  kubeadmapiv1beta1.SchemeGroupVersion,

cmd/kubeadm/app/util/config/testdata/conversion/controlplane/v1alpha3.yaml

-apiEndpoint:
-  advertiseAddress: 192.168.2.2
-  bindPort: 6443
-apiVersion: kubeadm.k8s.io/v1alpha3
-bootstrapTokens:
-- groups:
-  - system:bootstrappers:kubeadm:default-node-token
-  token: s73ybu.6tw6wnqgp5z0wb77
-  ttl: 24h0m0s
-  usages:
-  - signing
-  - authentication
-kind: InitConfiguration
-nodeRegistration:
-  criSocket: /var/run/dockershim.sock
-  name: control-plane-1
-  taints:
-  - effect: NoSchedule
-    key: node-role.kubernetes.io/master
----
-apiServerExtraArgs:
-  authorization-mode: Node,RBAC,Webhook
-apiServerExtraVolumes:
-- hostPath: /host/read-only
-  mountPath: /mount/read-only
-  name: ReadOnlyVolume
-- hostPath: /host/writable
-  mountPath: /mount/writable
-  name: WritableVolume
-  writable: true
-apiVersion: kubeadm.k8s.io/v1alpha3
-auditPolicy:
-  logDir: /var/log/kubernetes/audit
-  logMaxAge: 2
-  path: ""
-certificatesDir: /etc/kubernetes/pki
-clusterName: kubernetes
-controlPlaneEndpoint: ""
-etcd:
-  local:
-    dataDir: /var/lib/etcd
-    image: ""
-imageRepository: k8s.gcr.io
-kind: ClusterConfiguration
-kubernetesVersion: v1.12.2
-networking:
-  dnsDomain: cluster.local
-  podSubnet: ""
-  serviceSubnet: 10.96.0.0/12
-unifiedControlPlaneImage: "k8s.gcr.io/hyperkube:v1.12.2"
----
-apiVersion: kubeproxy.config.k8s.io/v1alpha1
-bindAddress: 0.0.0.0
-clientConnection:
-  acceptContentTypes: ""
-  burst: 10
-  contentType: application/vnd.kubernetes.protobuf
-  kubeconfig: /var/lib/kube-proxy/kubeconfig.conf
-  qps: 5
-clusterCIDR: ""
-configSyncPeriod: 15m0s
-conntrack:
-  max: null
-  maxPerCore: 32768
-  min: 131072
-  tcpCloseWaitTimeout: 1h0m0s
-  tcpEstablishedTimeout: 24h0m0s
-enableProfiling: false
-featureGates:
-  ServiceNodeExclusion: true
-  SupportIPVSProxyMode: true
-healthzBindAddress: 0.0.0.0:10256
-hostnameOverride: ""
-iptables:
-  masqueradeAll: false
-  masqueradeBit: 14
-  minSyncPeriod: 0s
-  syncPeriod: 30s
-ipvs:
-  excludeCIDRs: null
-  minSyncPeriod: 0s
-  scheduler: ""
-  syncPeriod: 30s
-kind: KubeProxyConfiguration
-metricsBindAddress: 127.0.0.1:10249
-mode: iptables
-nodePortAddresses: null
-oomScoreAdj: -999
-portRange: ""
-resourceContainer: /kube-proxy
-udpIdleTimeout: 250ms
-winkernel:
-  enableDSR: false
-  networkName: ""
-  sourceVip: ""
----
-address: 1.2.3.4
-apiVersion: kubelet.config.k8s.io/v1beta1
-authentication:
-  anonymous:
-    enabled: false
-  webhook:
-    cacheTTL: 2m0s
-    enabled: true
-  x509:
-    clientCAFile: /etc/kubernetes/pki/ca.crt
-authorization:
-  mode: Webhook
-  webhook:
-    cacheAuthorizedTTL: 5m0s
-    cacheUnauthorizedTTL: 30s
-cgroupDriver: cgroupfs
-cgroupsPerQOS: true
-clusterDNS:
-- 10.96.0.10
-clusterDomain: cluster.local
-configMapAndSecretChangeDetectionStrategy: Watch
-containerLogMaxFiles: 5
-containerLogMaxSize: 10Mi
-contentType: application/vnd.kubernetes.protobuf
-cpuCFSQuota: true
-cpuCFSQuotaPeriod: 0s
-cpuManagerPolicy: none
-cpuManagerReconcilePeriod: 10s
-enableControllerAttachDetach: true
-enableDebuggingHandlers: true
-enforceNodeAllocatable:
-- pods
-eventBurst: 10
-eventRecordQPS: 5
-evictionHard:
-  imagefs.available: 15%
-  memory.available: 100Mi
-  nodefs.available: 10%
-  nodefs.inodesFree: 5%
-evictionPressureTransitionPeriod: 5m0s
-failSwapOn: true
-fileCheckFrequency: 20s
-hairpinMode: promiscuous-bridge
-healthzBindAddress: 127.0.0.1
-healthzPort: 10248
-httpCheckFrequency: 20s
-imageGCHighThresholdPercent: 85
-imageGCLowThresholdPercent: 80
-imageMinimumGCAge: 2m0s
-iptablesDropBit: 15
-iptablesMasqueradeBit: 14
-kind: KubeletConfiguration
-kubeAPIBurst: 10
-kubeAPIQPS: 5
-makeIPTablesUtilChains: true
-maxOpenFiles: 1000000
-maxPods: 110
-nodeLeaseDurationSeconds: 40
-nodeStatusReportFrequency: 1m0s
-nodeStatusUpdateFrequency: 10s
-oomScoreAdj: -999
-podPidsLimit: -1
-port: 10250
-registryBurst: 10
-registryPullQPS: 5
-resolvConf: /etc/resolv.conf
-rotateCertificates: true
-runtimeRequestTimeout: 2m0s
-serializeImagePulls: true
-staticPodPath: /etc/kubernetes/manifests
-streamingConnectionIdleTimeout: 4h0m0s
-syncFrequency: 1m0s
-volumeStatsAggPeriod: 1m0s

cmd/kubeadm/app/util/config/testdata/conversion/controlplane/v1alpha3_non_linux.yaml

-apiEndpoint:
-  advertiseAddress: 192.168.2.2
-  bindPort: 6443
-apiVersion: kubeadm.k8s.io/v1alpha3
-bootstrapTokens:
-- groups:
-  - system:bootstrappers:kubeadm:default-node-token
-  token: s73ybu.6tw6wnqgp5z0wb77
-  ttl: 24h0m0s
-  usages:
-  - signing
-  - authentication
-kind: InitConfiguration
-nodeRegistration:
-  criSocket: /var/run/dockershim.sock
-  name: control-plane-1
-  taints:
-  - effect: NoSchedule
-    key: node-role.kubernetes.io/master
----
-apiServerExtraArgs:
-  authorization-mode: Node,RBAC,Webhook
-apiServerExtraVolumes:
-- hostPath: /host/read-only
-  mountPath: /mount/read-only
-  name: ReadOnlyVolume
-- hostPath: /host/writable
-  mountPath: /mount/writable
-  name: WritableVolume
-  writable: true
-apiVersion: kubeadm.k8s.io/v1alpha3
-auditPolicy:
-  logDir: /var/log/kubernetes/audit
-  logMaxAge: 2
-  path: ""
-certificatesDir: /etc/kubernetes/pki
-clusterName: kubernetes
-controlPlaneEndpoint: ""
-etcd:
-  local:
-    dataDir: /var/lib/etcd
-    image: ""
-imageRepository: k8s.gcr.io
-kind: ClusterConfiguration
-kubernetesVersion: v1.12.2
-networking:
-  dnsDomain: cluster.local
-  podSubnet: ""
-  serviceSubnet: 10.96.0.0/12
-unifiedControlPlaneImage: "k8s.gcr.io/hyperkube:v1.12.2"
----
-apiVersion: kubeproxy.config.k8s.io/v1alpha1
-bindAddress: 0.0.0.0
-clientConnection:
-  acceptContentTypes: ""
-  burst: 10
-  contentType: application/vnd.kubernetes.protobuf
-  kubeconfig: /var/lib/kube-proxy/kubeconfig.conf
-  qps: 5
-clusterCIDR: ""
-configSyncPeriod: 15m0s
-conntrack:
-  max: null
-  maxPerCore: 32768
-  min: 131072
-  tcpCloseWaitTimeout: 1h0m0s
-  tcpEstablishedTimeout: 24h0m0s
-enableProfiling: false
-featureGates:
-  ServiceNodeExclusion: true
-  SupportIPVSProxyMode: true
-healthzBindAddress: 0.0.0.0:10256
-hostnameOverride: ""
-iptables:
-  masqueradeAll: false
-  masqueradeBit: 14
-  minSyncPeriod: 0s
-  syncPeriod: 30s
-ipvs:
-  excludeCIDRs: null
-  minSyncPeriod: 0s
-  scheduler: ""
-  syncPeriod: 30s
-kind: KubeProxyConfiguration
-metricsBindAddress: 127.0.0.1:10249
-mode: iptables
-nodePortAddresses: null
-oomScoreAdj: -999
-portRange: ""
-resourceContainer: /kube-proxy
-udpIdleTimeout: 250ms
-winkernel:
-  enableDSR: false
-  networkName: ""
-  sourceVip: ""
----
-address: 1.2.3.4
-apiVersion: kubelet.config.k8s.io/v1beta1
-authentication:
-  anonymous:
-    enabled: false
-  webhook:
-    cacheTTL: 2m0s
-    enabled: true
-  x509:
-    clientCAFile: /etc/kubernetes/pki/ca.crt
-authorization:
-  mode: Webhook
-  webhook:
-    cacheAuthorizedTTL: 5m0s
-    cacheUnauthorizedTTL: 30s
-cgroupDriver: cgroupfs
-cgroupsPerQOS: true
-clusterDNS:
-- 10.96.0.10
-clusterDomain: cluster.local
-configMapAndSecretChangeDetectionStrategy: Watch
-containerLogMaxFiles: 5
-containerLogMaxSize: 10Mi
-contentType: application/vnd.kubernetes.protobuf
-cpuCFSQuota: true
-cpuCFSQuotaPeriod: 0s
-cpuManagerPolicy: none
-cpuManagerReconcilePeriod: 10s
-enableControllerAttachDetach: true
-enableDebuggingHandlers: true
-enforceNodeAllocatable:
-- pods
-eventBurst: 10
-eventRecordQPS: 5
-evictionHard:
-  imagefs.available: 15%
-  memory.available: 100Mi
-  nodefs.available: 10%
-evictionPressureTransitionPeriod: 5m0s
-failSwapOn: true
-fileCheckFrequency: 20s
-hairpinMode: promiscuous-bridge
-healthzBindAddress: 127.0.0.1
-healthzPort: 10248
-httpCheckFrequency: 20s
-imageGCHighThresholdPercent: 85
-imageGCLowThresholdPercent: 80
-imageMinimumGCAge: 2m0s
-iptablesDropBit: 15
-iptablesMasqueradeBit: 14
-kind: KubeletConfiguration
-kubeAPIBurst: 10
-kubeAPIQPS: 5
-makeIPTablesUtilChains: true
-maxOpenFiles: 1000000
-maxPods: 110
-nodeLeaseDurationSeconds: 40
-nodeStatusReportFrequency: 1m0s
-nodeStatusUpdateFrequency: 10s
-oomScoreAdj: -999
-podPidsLimit: -1
-port: 10250
-registryBurst: 10
-registryPullQPS: 5
-resolvConf: /etc/resolv.conf
-rotateCertificates: true
-runtimeRequestTimeout: 2m0s
-serializeImagePulls: true
-staticPodPath: /etc/kubernetes/manifests
-streamingConnectionIdleTimeout: 4h0m0s
-syncFrequency: 1m0s
-volumeStatsAggPeriod: 1m0s

cmd/kubeadm/app/util/config/testdata/conversion/node/v1alpha3.yaml

-apiEndpoint:
-  advertiseAddress: 192.168.2.2
-  bindPort: 6443
-apiVersion: kubeadm.k8s.io/v1alpha3
-caCertPath: /etc/kubernetes/pki/ca.crt
-controlPlane: true
-discoveryFile: ""
-discoveryTimeout: 5m0s
-discoveryToken: abcdef.0123456789abcdef
-discoveryTokenAPIServers:
-- kube-apiserver:6443
-discoveryTokenUnsafeSkipCAVerification: true
-kind: JoinConfiguration
-nodeRegistration:
-  criSocket: /var/run/dockershim.sock
-  name: control-plane-1
-  taints:
-  - effect: NoSchedule
-    key: node-role.kubernetes.io/master
-tlsBootstrapToken: abcdef.0123456789abcdef
-token: abcdef.0123456789abcdef

cmd/kubeadm/test/cmd/init_test.go

@@ -156,7 +156,7 @@ func TestCmdInitConfig(t *testing.T) {
 			expected: false,
 		},
 		{
-			name:     "can't load deprecated v1alpha3 config",
+			name:     "can't load old v1alpha3 config",
 			args:     "--config=testdata/init/v1alpha3.yaml",
 			expected: false,
 		},
@@ -166,11 +166,6 @@ func TestCmdInitConfig(t *testing.T) {
 			expected: true,
 		},
 		{
-			name:     "don't allow mixed arguments v1alpha3",
-			args:     "--kubernetes-version=1.11.0 --config=testdata/init/v1alpha3.yaml",
-			expected: false,
-		},
-		{
 			name:     "don't allow mixed arguments v1beta1",
 			args:     "--kubernetes-version=1.11.0 --config=testdata/init/v1beta1.yaml",
 			expected: false,

hack/.golint_failures

@@ -2,7 +2,6 @@ cmd/cloud-controller-manager/app/apis/config/v1alpha1
 cmd/kube-apiserver/app
 cmd/kube-controller-manager/app
 cmd/kube-proxy/app
-cmd/kubeadm/app/apis/kubeadm/v1alpha3
 cmd/kubeadm/app/apis/kubeadm/v1beta1
 cmd/kubeadm/app/util/system
 pkg/apis/abac/latest