Merge pull request #64761 from rosti/kubeadm-dnsverfix

cmd/kubeadm/app/constants/constants.go

@@ -273,6 +273,12 @@ const (
 
 	// KubeletEnvFileVariableName specifies the shell script variable name "kubeadm init" should write a value to in KubeletEnvFile
 	KubeletEnvFileVariableName = "KUBELET_KUBEADM_ARGS"
+
+	// KubeDNSVersion is the version of kube-dns to be deployed if it is used
+	KubeDNSVersion = "1.14.10"
+
+	// CoreDNSVersion is the version of CoreDNS to be deployed if it is used
+	CoreDNSVersion = "1.1.3"
 )
 
 var (
@@ -402,3 +408,13 @@ func GetDNSIP(svcSubnet string) (net.IP, error) {
 func GetStaticPodAuditPolicyFile() string {
 	return filepath.Join(KubernetesDir, AuditPolicyDir, AuditPolicyFile)
 }
+
+// GetDNSVersion is a handy function that returns the DNS version by DNS type
+func GetDNSVersion(dnsType string) string {
+	switch dnsType {
+	case CoreDNS:
+		return CoreDNSVersion
+	default:
+		return KubeDNSVersion
+	}
+}

cmd/kubeadm/app/constants/constants_test.go

@@ -172,3 +172,29 @@ func TestEtcdSupportedVersion(t *testing.T) {
 		}
 	}
 }
+
+func TestGetKubeDNSVersion(t *testing.T) {
+	var tests = []struct {
+		dns      string
+		expected string
+	}{
+		{
+			dns:      KubeDNS,
+			expected: KubeDNSVersion,
+		},
+		{
+			dns:      CoreDNS,
+			expected: CoreDNSVersion,
+		},
+	}
+	for _, rt := range tests {
+		actualDNSVersion := GetDNSVersion(rt.dns)
+		if actualDNSVersion != rt.expected {
+			t.Errorf(
+				"failed GetDNSVersion:\n\texpected: %s\n\t  actual: %s",
+				rt.expected,
+				actualDNSVersion,
+			)
+		}
+	}
+}

cmd/kubeadm/app/images/BUILD

@@ -18,7 +18,6 @@ go_library(
         "//cmd/kubeadm/app/apis/kubeadm/v1alpha2:go_default_library",
         "//cmd/kubeadm/app/constants:go_default_library",
         "//cmd/kubeadm/app/features:go_default_library",
-        "//cmd/kubeadm/app/phases/addons/dns:go_default_library",
         "//cmd/kubeadm/app/util:go_default_library",
         "//vendor/k8s.io/utils/exec:go_default_library",
     ],

cmd/kubeadm/app/images/images.go

@@ -23,7 +23,6 @@ import (
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	"k8s.io/kubernetes/cmd/kubeadm/app/features"
-	"k8s.io/kubernetes/cmd/kubeadm/app/phases/addons/dns"
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
 )
 
@@ -60,9 +59,9 @@ func GetAllImages(cfg *kubeadmapi.MasterConfiguration) []string {
 		imgs = append(imgs, GetCoreImage(constants.Etcd, cfg.ImageRepository, cfg.KubernetesVersion, cfg.Etcd.Local.Image))
 	}
 
-	dnsImage := fmt.Sprintf("%v/k8s-dns-kube-dns-%v:%v", cfg.ImageRepository, runtime.GOARCH, dns.GetDNSVersion(nil, constants.KubeDNS))
+	dnsImage := fmt.Sprintf("%v/k8s-dns-kube-dns-%v:%v", cfg.ImageRepository, runtime.GOARCH, constants.KubeDNSVersion)
 	if features.Enabled(cfg.FeatureGates, features.CoreDNS) {
-		dnsImage = fmt.Sprintf("coredns/coredns:%v", dns.GetDNSVersion(nil, constants.CoreDNS))
+		dnsImage = fmt.Sprintf("coredns/coredns:%v", constants.CoreDNSVersion)
 	}
 	imgs = append(imgs, dnsImage)
 	return imgs

cmd/kubeadm/app/phases/addons/dns/BUILD

@@ -8,16 +8,12 @@ load(
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "dns_test.go",
-        "versions_test.go",
-    ],
+    srcs = ["dns_test.go"],
     embed = [":go_default_library"],
     deps = [
         "//cmd/kubeadm/app/constants:go_default_library",
         "//cmd/kubeadm/app/util:go_default_library",
         "//pkg/apis/core:go_default_library",
-        "//pkg/util/version:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
@@ -32,7 +28,6 @@ go_library(
     srcs = [
         "dns.go",
         "manifests.go",
-        "versions.go",
     ],
     importpath = "k8s.io/kubernetes/cmd/kubeadm/app/phases/addons/dns",
     deps = [
@@ -41,7 +36,6 @@ go_library(
         "//cmd/kubeadm/app/features:go_default_library",
         "//cmd/kubeadm/app/util:go_default_library",
         "//cmd/kubeadm/app/util/apiclient:go_default_library",
-        "//pkg/util/version:go_default_library",
         "//vendor/github.com/mholt/caddy/caddyfile:go_default_library",
         "//vendor/k8s.io/api/apps/v1:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",

cmd/kubeadm/app/phases/addons/dns/dns.go

@@ -37,7 +37,6 @@ import (
 	"k8s.io/kubernetes/cmd/kubeadm/app/features"
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
 	"k8s.io/kubernetes/cmd/kubeadm/app/util/apiclient"
-	"k8s.io/kubernetes/pkg/util/version"
 )
 
 const (
@@ -72,17 +71,13 @@ func DeployedDNSAddon(client clientset.Interface) (string, string, error) {
 
 // EnsureDNSAddon creates the kube-dns or CoreDNS addon
 func EnsureDNSAddon(cfg *kubeadmapi.MasterConfiguration, client clientset.Interface) error {
-	k8sVersion, err := version.ParseSemantic(cfg.KubernetesVersion)
-	if err != nil {
-		return fmt.Errorf("couldn't parse kubernetes version %q: %v", cfg.KubernetesVersion, err)
-	}
 	if features.Enabled(cfg.FeatureGates, features.CoreDNS) {
-		return coreDNSAddon(cfg, client, k8sVersion)
+		return coreDNSAddon(cfg, client)
 	}
-	return kubeDNSAddon(cfg, client, k8sVersion)
+	return kubeDNSAddon(cfg, client)
 }
 
-func kubeDNSAddon(cfg *kubeadmapi.MasterConfiguration, client clientset.Interface, k8sVersion *version.Version) error {
+func kubeDNSAddon(cfg *kubeadmapi.MasterConfiguration, client clientset.Interface) error {
 	if err := CreateServiceAccount(client); err != nil {
 		return err
 	}
@@ -101,18 +96,15 @@ func kubeDNSAddon(cfg *kubeadmapi.MasterConfiguration, client clientset.Interfac
 		dnsProbeAddr = dnsBindAddr
 	}
 
-	// Get the YAML manifest conditionally based on the k8s version
-	kubeDNSDeploymentBytes := GetKubeDNSManifest(k8sVersion)
-	dnsDeploymentBytes, err := kubeadmutil.ParseTemplate(kubeDNSDeploymentBytes,
+	dnsDeploymentBytes, err := kubeadmutil.ParseTemplate(KubeDNSDeployment,
 		struct{ ImageRepository, Arch, Version, DNSBindAddr, DNSProbeAddr, DNSDomain, MasterTaintKey string }{
 			ImageRepository: cfg.ImageRepository,
 			Arch:            runtime.GOARCH,
-			// Get the kube-dns version conditionally based on the k8s version
-			Version:        GetDNSVersion(k8sVersion, kubeadmconstants.KubeDNS),
-			DNSBindAddr:    dnsBindAddr,
-			DNSProbeAddr:   dnsProbeAddr,
-			DNSDomain:      cfg.Networking.DNSDomain,
-			MasterTaintKey: kubeadmconstants.LabelNodeRoleMaster,
+			Version:         kubeadmconstants.KubeDNSVersion,
+			DNSBindAddr:     dnsBindAddr,
+			DNSProbeAddr:    dnsProbeAddr,
+			DNSDomain:       cfg.Networking.DNSDomain,
+			MasterTaintKey:  kubeadmconstants.LabelNodeRoleMaster,
 		})
 	if err != nil {
 		return fmt.Errorf("error when parsing kube-dns deployment template: %v", err)
@@ -158,13 +150,12 @@ func createKubeDNSAddon(deploymentBytes, serviceBytes []byte, client clientset.I
 	return createDNSService(kubednsService, serviceBytes, client)
 }
 
-func coreDNSAddon(cfg *kubeadmapi.MasterConfiguration, client clientset.Interface, k8sVersion *version.Version) error {
-	// Get the YAML manifest conditionally based on the k8s version
-	dnsDeploymentBytes := GetCoreDNSManifest(k8sVersion)
-	coreDNSDeploymentBytes, err := kubeadmutil.ParseTemplate(dnsDeploymentBytes, struct{ ImageRepository, MasterTaintKey, Version string }{
+func coreDNSAddon(cfg *kubeadmapi.MasterConfiguration, client clientset.Interface) error {
+	// Get the YAML manifest
+	coreDNSDeploymentBytes, err := kubeadmutil.ParseTemplate(CoreDNSDeployment, struct{ ImageRepository, MasterTaintKey, Version string }{
 		ImageRepository: cfg.ImageRepository,
 		MasterTaintKey:  kubeadmconstants.LabelNodeRoleMaster,
-		Version:         GetDNSVersion(k8sVersion, kubeadmconstants.CoreDNS),
+		Version:         kubeadmconstants.CoreDNSVersion,
 	})
 	if err != nil {
 		return fmt.Errorf("error when parsing CoreDNS deployment template: %v", err)

cmd/kubeadm/app/phases/addons/dns/versions.go

-/*
-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 dns
-
-import (
-	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
-	"k8s.io/kubernetes/pkg/util/version"
-)
-
-const (
-	kubeDNSVersion = "1.14.10"
-	coreDNSVersion = "1.1.3"
-)
-
-// GetDNSVersion returns the right kube-dns version for a specific k8s version
-func GetDNSVersion(kubeVersion *version.Version, dns string) string {
-	// v1.9.0+ uses kube-dns 1.14.10, if feature gate "CoreDNS" is disabled.
-	// v1.9.0+ uses CoreDNS  1.1.3.
-
-	// In the future when the version is bumped at HEAD; add conditional logic to return the right versions
-	// Also, the version might be bumped for different k8s releases on the same branch
-	switch dns {
-	case kubeadmconstants.CoreDNS:
-		// return the CoreDNS version
-		return coreDNSVersion
-	default:
-		return kubeDNSVersion
-	}
-}
-
-// GetKubeDNSManifest returns the right kube-dns YAML manifest for a specific k8s version
-func GetKubeDNSManifest(kubeVersion *version.Version) string {
-	// v1.8.0+ has only one known YAML manifest spec, just return that here
-	// In the future when the kube-dns version is bumped at HEAD; add conditional logic to return the right manifest
-	return KubeDNSDeployment
-}
-
-// GetCoreDNSManifest returns the right CoreDNS YAML manifest for a specific k8s version
-func GetCoreDNSManifest(kubeVersion *version.Version) string {
-	// v1.9.0+ has only one known YAML manifest spec, just return that here
-	// In the future when the CoreDNS version is bumped at HEAD; add conditional logic to return the right manifest
-	return CoreDNSDeployment
-}

cmd/kubeadm/app/phases/addons/dns/versions_test.go

-/*
-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 dns
-
-import (
-	"testing"
-
-	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
-	"k8s.io/kubernetes/pkg/util/version"
-)
-
-func TestGetKubeDNSVersion(t *testing.T) {
-	var tests = []struct {
-		k8sVersion string
-		dns        string
-		expected   string
-	}{
-		{
-			k8sVersion: "v1.9.0",
-			dns:        kubeadmconstants.KubeDNS,
-			expected:   kubeDNSVersion,
-		},
-		{
-			k8sVersion: "v1.10.0",
-			dns:        kubeadmconstants.KubeDNS,
-			expected:   kubeDNSVersion,
-		},
-		{
-			k8sVersion: "v1.9.0",
-			dns:        kubeadmconstants.CoreDNS,
-			expected:   coreDNSVersion,
-		},
-		{
-			k8sVersion: "v1.10.0",
-			dns:        kubeadmconstants.CoreDNS,
-			expected:   coreDNSVersion,
-		},
-	}
-	for _, rt := range tests {
-		k8sVersion, err := version.ParseSemantic(rt.k8sVersion)
-		if err != nil {
-			t.Fatalf("couldn't parse kubernetes version %q: %v", rt.k8sVersion, err)
-		}
-
-		actualDNSVersion := GetDNSVersion(k8sVersion, rt.dns)
-		if actualDNSVersion != rt.expected {
-			t.Errorf(
-				"failed GetDNSVersion:\n\texpected: %s\n\t  actual: %s",
-				rt.expected,
-				actualDNSVersion,
-			)
-		}
-	}
-}

cmd/kubeadm/app/phases/upgrade/compute.go

@@ -173,7 +173,7 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
 					After: ClusterState{
 						KubeVersion:    patchVersionStr,
 						DNSType:        ActiveDNSAddon(featureGates),
-						DNSVersion:     dns.GetDNSVersion(patchVersion, ActiveDNSAddon(featureGates)),
+						DNSVersion:     kubeadmconstants.GetDNSVersion(ActiveDNSAddon(featureGates)),
 						KubeadmVersion: newKubeadmVer,
 						EtcdVersion:    getSuggestedEtcdVersion(patchVersionStr),
 						// KubeletVersions is unset here as it is not used anywhere in .After
@@ -190,7 +190,7 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
 			After: ClusterState{
 				KubeVersion:    stableVersionStr,
 				DNSType:        ActiveDNSAddon(featureGates),
-				DNSVersion:     dns.GetDNSVersion(stableVersion, ActiveDNSAddon(featureGates)),
+				DNSVersion:     kubeadmconstants.GetDNSVersion(ActiveDNSAddon(featureGates)),
 				KubeadmVersion: stableVersionStr,
 				EtcdVersion:    getSuggestedEtcdVersion(stableVersionStr),
 				// KubeletVersions is unset here as it is not used anywhere in .After
@@ -236,7 +236,7 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
 				After: ClusterState{
 					KubeVersion:    previousBranchLatestVersionStr,
 					DNSType:        ActiveDNSAddon(featureGates),
-					DNSVersion:     dns.GetDNSVersion(previousBranchLatestVersion, ActiveDNSAddon(featureGates)),
+					DNSVersion:     kubeadmconstants.GetDNSVersion(ActiveDNSAddon(featureGates)),
 					KubeadmVersion: previousBranchLatestVersionStr,
 					EtcdVersion:    getSuggestedEtcdVersion(previousBranchLatestVersionStr),
 					// KubeletVersions is unset here as it is not used anywhere in .After
@@ -249,12 +249,12 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
 
 			// Default to assume that the experimental version to show is the unstable one
 			unstableKubeVersion := latestVersionStr
-			unstableKubeDNSVersion := dns.GetDNSVersion(latestVersion, ActiveDNSAddon(featureGates))
+			unstableKubeDNSVersion := kubeadmconstants.GetDNSVersion(ActiveDNSAddon(featureGates))
 
 			// Ẃe should not display alpha.0. The previous branch's beta/rc versions are more relevant due how the kube branching process works.
 			if latestVersion.PreRelease() == "alpha.0" {
 				unstableKubeVersion = previousBranchLatestVersionStr
-				unstableKubeDNSVersion = dns.GetDNSVersion(previousBranchLatestVersion, ActiveDNSAddon(featureGates))
+				unstableKubeDNSVersion = kubeadmconstants.GetDNSVersion(ActiveDNSAddon(featureGates))
 			}
 
 			upgrades = append(upgrades, Upgrade{