github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-22 03:11:40 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #101547 from neolit123/1.22-remove-dns-type

Browse Source 
kubeadm: remove ClusterConfiguration.DNS.Type from v1beta3
This commit is contained in:
Kubernetes Prow Robot 2021-05-15 00:27:58 -07:00 committed by GitHub
commit 3f43b1ed84
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 63 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
cmd/kubeadm/app/apis/kubeadm/types.go
View File

@ -146,16 +146,19 @@ type APIServer struct {
}
// DNSAddOnType defines string identifying DNS add-on types
// TODO: Remove with v1beta2 https://github.com/kubernetes/kubeadm/issues/2459
type DNSAddOnType string
const (
// CoreDNS add-on type
// TODO: Remove with v1beta2 https://github.com/kubernetes/kubeadm/issues/2459
CoreDNS DNSAddOnType = "CoreDNS"
)
// DNS defines the DNS addon that should be used in the cluster
type DNS struct {
// Type defines the DNS add-on to be used
// TODO: Used only in validation over the internal type. Remove with v1beta2 https://github.com/kubernetes/kubeadm/issues/2459
Type DNSAddOnType
// ImageMeta allows to customize the image used for the DNS component

19
cmd/kubeadm/app/apis/kubeadm/v1beta3/conversion.go
View File

@ -30,5 +30,22 @@ func Convert_v1beta3_InitConfiguration_To_kubeadm_InitConfiguration(in *InitConf
if err != nil {
return err
}
return Convert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration(&ClusterConfiguration{}, &out.ClusterConfiguration, s)
err = Convert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration(&ClusterConfiguration{}, &out.ClusterConfiguration, s)
// Make roundtrip / fuzzers happy
// TODO: Remove with v1beta2 https://github.com/kubernetes/kubeadm/issues/2459
out.DNS.Type = ""
return err
}
// Convert_kubeadm_DNS_To_v1beta3_DNS is required since Type does not exist in the DNS struct
// TODO: Remove with v1beta2 https://github.com/kubernetes/kubeadm/issues/2459
func Convert_kubeadm_DNS_To_v1beta3_DNS(in *kubeadm.DNS, out *DNS, s conversion.Scope) error {
return autoConvert_kubeadm_DNS_To_v1beta3_DNS(in, out, s)
}
// Convert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration is required due to the missing
// DNS.Type in v1beta3. TODO: Remove with v1beta2 https://github.com/kubernetes/kubeadm/issues/2459
func Convert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration(in *ClusterConfiguration, out *kubeadm.ClusterConfiguration, s conversion.Scope) error {
out.DNS.Type = kubeadm.CoreDNS
return autoConvert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration(in, out, s)
}

8
cmd/kubeadm/app/apis/kubeadm/v1beta3/defaults.go
View File

@ -97,7 +97,6 @@ func SetDefaults_ClusterConfiguration(obj *ClusterConfiguration) {
obj.ClusterName = DefaultClusterName
}
SetDefaults_DNS(obj)
SetDefaults_Etcd(obj)
SetDefaults_APIServer(&obj.APIServer)
}
@ -111,13 +110,6 @@ func SetDefaults_APIServer(obj *APIServer) {
}
}
// SetDefaults_DNS assigns default values for the DNS component
func SetDefaults_DNS(obj *ClusterConfiguration) {
if obj.DNS.Type == "" {
obj.DNS.Type = CoreDNS
}
}
// SetDefaults_Etcd assigns default values for the proxy
func SetDefaults_Etcd(obj *ClusterConfiguration) {
if obj.Etcd.External == nil && obj.Etcd.Local == nil {

2
cmd/kubeadm/app/apis/kubeadm/v1beta3/doc.go
View File

@ -25,6 +25,8 @@ limitations under the License.
// A list of changes since v1beta2:
// - The deprecated "ClusterConfiguration.useHyperKubeImage" field has been removed.
// Kubeadm no longer supports the hyperkube image.
// - The "ClusterConfiguration.DNS.Type" field has been removed since CoreDNS is the only supported
// DNS server type by kubeadm.
//
// Migration from old kubeadm config versions
//

8
cmd/kubeadm/app/apis/kubeadm/v1beta3/types.go
View File

@ -133,16 +133,8 @@ type APIServer struct {
// DNSAddOnType defines string identifying DNS add-on types
type DNSAddOnType string
const (
// CoreDNS add-on type
CoreDNS DNSAddOnType = "CoreDNS"
)
// DNS defines the DNS addon that should be used in the cluster
type DNS struct {
// Type defines the DNS add-on to be used
Type DNSAddOnType `json:"type"`
// ImageMeta allows to customize the image used for the DNS component
ImageMeta `json:",inline"`
}

33
cmd/kubeadm/app/apis/kubeadm/v1beta3/zz_generated.conversion.go generated
View File

@ -87,11 +87,6 @@ func RegisterConversions(s *runtime.Scheme) error {
}); err != nil {
return err
}
if err := s.AddGeneratedConversionFunc((*ClusterConfiguration)(nil), (*kubeadm.ClusterConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration(a.(*ClusterConfiguration), b.(*kubeadm.ClusterConfiguration), scope)
}); err != nil {
return err
}
if err := s.AddGeneratedConversionFunc((*kubeadm.ClusterConfiguration)(nil), (*ClusterConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_kubeadm_ClusterConfiguration_To_v1beta3_ClusterConfiguration(a.(*kubeadm.ClusterConfiguration), b.(*ClusterConfiguration), scope)
}); err != nil {
@ -122,11 +117,6 @@ func RegisterConversions(s *runtime.Scheme) error {
}); err != nil {
return err
}
if err := s.AddGeneratedConversionFunc((*kubeadm.DNS)(nil), (*DNS)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_kubeadm_DNS_To_v1beta3_DNS(a.(*kubeadm.DNS), b.(*DNS), scope)
}); err != nil {
return err
}
if err := s.AddGeneratedConversionFunc((*Discovery)(nil), (*kubeadm.Discovery)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_v1beta3_Discovery_To_kubeadm_Discovery(a.(*Discovery), b.(*kubeadm.Discovery), scope)
}); err != nil {
@ -237,11 +227,21 @@ func RegisterConversions(s *runtime.Scheme) error {
}); err != nil {
return err
}
if err := s.AddConversionFunc((*kubeadm.DNS)(nil), (*DNS)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_kubeadm_DNS_To_v1beta3_DNS(a.(*kubeadm.DNS), b.(*DNS), scope)
}); err != nil {
return err
}
if err := s.AddConversionFunc((*kubeadm.InitConfiguration)(nil), (*InitConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_kubeadm_InitConfiguration_To_v1beta3_InitConfiguration(a.(*kubeadm.InitConfiguration), b.(*InitConfiguration), scope)
}); err != nil {
return err
}
if err := s.AddConversionFunc((*ClusterConfiguration)(nil), (*kubeadm.ClusterConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration(a.(*ClusterConfiguration), b.(*kubeadm.ClusterConfiguration), scope)
}); err != nil {
return err
}
if err := s.AddConversionFunc((*InitConfiguration)(nil), (*kubeadm.InitConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_v1beta3_InitConfiguration_To_kubeadm_InitConfiguration(a.(*InitConfiguration), b.(*kubeadm.InitConfiguration), scope)
}); err != nil {
@ -406,11 +406,6 @@ func autoConvert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration(in
return nil
}
// Convert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration is an autogenerated conversion function.
func Convert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration(in *ClusterConfiguration, out *kubeadm.ClusterConfiguration, s conversion.Scope) error {
return autoConvert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration(in, out, s)
}
func autoConvert_kubeadm_ClusterConfiguration_To_v1beta3_ClusterConfiguration(in *kubeadm.ClusterConfiguration, out *ClusterConfiguration, s conversion.Scope) error {
// INFO: in.ComponentConfigs opted out of conversion generation
if err := Convert_kubeadm_Etcd_To_v1beta3_Etcd(&in.Etcd, &out.Etcd, s); err != nil {
@ -489,7 +484,6 @@ func Convert_kubeadm_ControlPlaneComponent_To_v1beta3_ControlPlaneComponent(in *
}
func autoConvert_v1beta3_DNS_To_kubeadm_DNS(in *DNS, out *kubeadm.DNS, s conversion.Scope) error {
out.Type = kubeadm.DNSAddOnType(in.Type)
if err := Convert_v1beta3_ImageMeta_To_kubeadm_ImageMeta(&in.ImageMeta, &out.ImageMeta, s); err != nil {
return err
}
@ -502,18 +496,13 @@ func Convert_v1beta3_DNS_To_kubeadm_DNS(in *DNS, out *kubeadm.DNS, s conversion.
}
func autoConvert_kubeadm_DNS_To_v1beta3_DNS(in *kubeadm.DNS, out *DNS, s conversion.Scope) error {
out.Type = DNSAddOnType(in.Type)
// WARNING: in.Type requires manual conversion: does not exist in peer-type
if err := Convert_kubeadm_ImageMeta_To_v1beta3_ImageMeta(&in.ImageMeta, &out.ImageMeta, s); err != nil {
return err
}
return nil
}
// Convert_kubeadm_DNS_To_v1beta3_DNS is an autogenerated conversion function.
func Convert_kubeadm_DNS_To_v1beta3_DNS(in *kubeadm.DNS, out *DNS, s conversion.Scope) error {
return autoConvert_kubeadm_DNS_To_v1beta3_DNS(in, out, s)
}
func autoConvert_v1beta3_Discovery_To_kubeadm_Discovery(in *Discovery, out *kubeadm.Discovery, s conversion.Scope) error {
out.BootstrapToken = (*kubeadm.BootstrapTokenDiscovery)(unsafe.Pointer(in.BootstrapToken))
out.File = (*kubeadm.FileDiscovery)(unsafe.Pointer(in.File))

1
cmd/kubeadm/app/apis/kubeadm/validation/validation.go
View File

@ -493,6 +493,7 @@ func getClusterNodeMask(c *kubeadm.ClusterConfiguration, isIPv6 bool) (int, erro
}
// ValidateDNS validates the DNS object and collects all encountered errors
// TODO: Remove with v1beta2 https://github.com/kubernetes/kubeadm/issues/2459
func ValidateDNS(dns *kubeadm.DNS, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
const kubeDNSType = "kube-dns"

2
cmd/kubeadm/app/cmd/upgrade/common.go
View File

@ -241,7 +241,7 @@ func runPreflightChecks(client clientset.Interface, ignorePreflightErrors sets.S
if err != nil {
return err
}
err = upgrade.RunCoreDNSMigrationCheck(client, ignorePreflightErrors, cfg.DNS.Type)
err = upgrade.RunCoreDNSMigrationCheck(client, ignorePreflightErrors)
if err != nil {
return err
}

12
cmd/kubeadm/app/cmd/upgrade/common_test.go
View File

@ -87,16 +87,12 @@ func TestPrintConfiguration(t *testing.T) {
DataDir: "/some/path",
},
},
DNS: kubeadmapi.DNS{
Type: kubeadmapi.CoreDNS,
},
},
expectedBytes: []byte(fmt.Sprintf(`[upgrade/config] Configuration used:
apiServer: {}
apiVersion: %s
controllerManager: {}
dns:
type: CoreDNS
dns: {}
etcd:
local:
dataDir: /some/path
@ -118,16 +114,12 @@ func TestPrintConfiguration(t *testing.T) {
Endpoints: []string{"https://one-etcd-instance:2379"},
},
},
DNS: kubeadmapi.DNS{
Type: kubeadmapi.CoreDNS,
},
},
expectedBytes: []byte(`[upgrade/config] Configuration used:
apiServer: {}
apiVersion: ` + kubeadmapiv1.SchemeGroupVersion.String() + `
controllerManager: {}
dns:
type: CoreDNS
dns: {}
etcd:
external:
caFile: ""

15
cmd/kubeadm/app/cmd/upgrade/plan.go
View File

@ -79,7 +79,7 @@ func runPlan(flags *planFlags, args []string) error {
// Compute which upgrade possibilities there are
klog.V(1).Infoln("[upgrade/plan] computing upgrade possibilities")
availUpgrades, err := upgrade.GetAvailableUpgrades(versionGetter, flags.allowExperimentalUpgrades, flags.allowRCUpgrades, isExternalEtcd, cfg.DNS.Type, client, constants.GetStaticPodDirectory())
availUpgrades, err := upgrade.GetAvailableUpgrades(versionGetter, flags.allowExperimentalUpgrades, flags.allowRCUpgrades, isExternalEtcd, client, constants.GetStaticPodDirectory())
if err != nil {
return errors.Wrap(err, "[upgrade/versions] FATAL")
}
@ -133,14 +133,9 @@ func newComponentUpgradePlan(name, currentVersion, newVersion string) outputapi.
// TODO There is currently no way to cleanly output upgrades that involve adding, removing, or changing components
// https://github.com/kubernetes/kubeadm/issues/810 was created to track addressing this.
func appendDNSComponent(components []outputapi.ComponentUpgradePlan, up *upgrade.Upgrade, DNSType kubeadmapi.DNSAddOnType, name string) []outputapi.ComponentUpgradePlan {
beforeVersion, afterVersion := "", ""
if up.Before.DNSType == DNSType {
beforeVersion = up.Before.DNSVersion
}
if up.After.DNSType == DNSType {
afterVersion = up.After.DNSVersion
}
func appendDNSComponent(components []outputapi.ComponentUpgradePlan, up *upgrade.Upgrade, name string) []outputapi.ComponentUpgradePlan {
beforeVersion := up.Before.DNSVersion
afterVersion := up.After.DNSVersion
if beforeVersion != "" || afterVersion != "" {
components = append(components, newComponentUpgradePlan(name, beforeVersion, afterVersion))
@ -180,7 +175,7 @@ func genUpgradePlan(up *upgrade.Upgrade, isExternalEtcd bool) (*outputapi.Upgrad
components = append(components, newComponentUpgradePlan(constants.KubeScheduler, up.Before.KubeVersion, up.After.KubeVersion))
components = append(components, newComponentUpgradePlan(constants.KubeProxy, up.Before.KubeVersion, up.After.KubeVersion))
components = appendDNSComponent(components, up, kubeadmapi.CoreDNS, constants.CoreDNS)
components = appendDNSComponent(components, up, constants.CoreDNS)
if !isExternalEtcd {
components = append(components, newComponentUpgradePlan(constants.Etcd, up.Before.EtcdVersion, up.After.EtcdVersion))

17
cmd/kubeadm/app/cmd/upgrade/plan_test.go
View File

@ -21,7 +21,6 @@ import (
"reflect"
"testing"
kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
"k8s.io/kubernetes/cmd/kubeadm/app/phases/upgrade"
)
@ -86,14 +85,12 @@ func TestPrintAvailableUpgrades(t *testing.T) {
"v1.18.1": 1,
},
KubeadmVersion: "v1.18.1",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.6.7",
EtcdVersion: "3.4.3-0",
},
After: upgrade.ClusterState{
KubeVersion: "v1.18.4",
KubeadmVersion: "v1.18.4",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.6.7",
EtcdVersion: "3.4.3-0",
},
@ -134,14 +131,12 @@ _____________________________________________________________________
"v1.18.4": 1,
},
KubeadmVersion: "v1.18.4",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.6.7",
EtcdVersion: "3.4.3-0",
},
After: upgrade.ClusterState{
KubeVersion: "v1.19.0",
KubeadmVersion: "v1.19.0",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.7.0",
EtcdVersion: "3.4.7-0",
},
@ -182,14 +177,12 @@ _____________________________________________________________________
"v1.18.3": 1,
},
KubeadmVersion: "v1.18.3",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.6.7",
EtcdVersion: "3.4.3-0",
},
After: upgrade.ClusterState{
KubeVersion: "v1.18.5",
KubeadmVersion: "v1.18.3",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.6.7",
EtcdVersion: "3.4.3-0",
},
@ -202,14 +195,12 @@ _____________________________________________________________________
"v1.18.3": 1,
},
KubeadmVersion: "v1.18.3",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.6.7",
EtcdVersion: "3.4.3-0",
},
After: upgrade.ClusterState{
KubeVersion: "v1.19.0",
KubeadmVersion: "v1.19.0",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.7.0",
EtcdVersion: "3.4.7-0",
},
@ -270,14 +261,12 @@ _____________________________________________________________________
"v1.18.5": 1,
},
KubeadmVersion: "v1.18.5",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.6.7",
EtcdVersion: "3.4.3-0",
},
After: upgrade.ClusterState{
KubeVersion: "v1.19.0-beta.1",
KubeadmVersion: "v1.19.0-beta.1",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.7.0",
EtcdVersion: "3.4.7-0",
},
@ -318,14 +307,12 @@ _____________________________________________________________________
"v1.18.5": 1,
},
KubeadmVersion: "v1.18.5",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.6.7",
EtcdVersion: "3.4.3-0",
},
After: upgrade.ClusterState{
KubeVersion: "v1.19.0-rc.1",
KubeadmVersion: "v1.19.0-rc.1",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.7.0",
EtcdVersion: "3.4.7-0",
},
@ -367,14 +354,12 @@ _____________________________________________________________________
"v1.19.3": 2,
},
KubeadmVersion: "v1.19.2",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.7.0",
EtcdVersion: "3.4.7-0",
},
After: upgrade.ClusterState{
KubeVersion: "v1.19.3",
KubeadmVersion: "v1.19.3",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.7.0",
EtcdVersion: "3.4.7-0",
},
@ -417,14 +402,12 @@ _____________________________________________________________________
"v1.19.2": 1,
},
KubeadmVersion: "v1.19.2",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.7.0",
EtcdVersion: "3.4.7-0",
},
After: upgrade.ClusterState{
KubeVersion: "v1.19.3",
KubeadmVersion: "v1.19.3",
DNSType: kubeadmapi.CoreDNS,
DNSVersion: "1.7.0",
EtcdVersion: "3.4.7-0",
},

8
cmd/kubeadm/app/componentconfigs/fakeconfig_test.go
View File

@ -210,8 +210,6 @@ var (
certificatesDir: /etc/kubernetes/pki
clusterName: LeCluster
controllerManager: {}
dns:
type: CoreDNS
etcd:
local:
dataDir: /var/lib/etcd
@ -236,9 +234,6 @@ var (
DNSDomain: "cluster.local",
ServiceSubnet: "10.96.0.0/12",
},
DNS: kubeadmapiv1.DNS{
Type: kubeadmapiv1.CoreDNS,
},
Etcd: kubeadmapiv1.Etcd{
Local: &kubeadmapiv1.LocalEtcd{
DataDir: "/var/lib/etcd",
@ -280,8 +275,7 @@ func TestConfigBaseMarshal(t *testing.T) {
apiVersion: %s
clusterName: LeCluster
controllerManager: {}
dns:
type: ""
dns: {}
etcd: {}
kind: ClusterConfiguration
kubernetesVersion: 1.2.3

9
cmd/kubeadm/app/constants/constants.go
View File

@ -32,7 +32,6 @@ import (
"k8s.io/apimachinery/pkg/util/version"
"k8s.io/apimachinery/pkg/util/wait"
bootstrapapi "k8s.io/cluster-bootstrap/token/api"
kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
utilnet "k8s.io/utils/net"
)
@ -635,14 +634,6 @@ func GetAPIServerVirtualIP(svcSubnetList string, isDualStack bool) (net.IP, erro
return internalAPIServerVirtualIP, nil
}
// GetDNSVersion is a handy function that returns the DNS version by DNS type
func GetDNSVersion(dnsType kubeadmapi.DNSAddOnType) string {
if dnsType == kubeadmapi.CoreDNS {
return CoreDNSVersion
}
return ""
}
// GetKubeletConfigMapName returns the right ConfigMap name for the right branch of k8s
func GetKubeletConfigMapName(k8sVersion *version.Version) string {
return fmt.Sprintf("%s%d.%d", KubeletBaseConfigurationConfigMapPrefix, k8sVersion.Major(), k8sVersion.Minor())

25
cmd/kubeadm/app/constants/constants_test.go
View File

@ -21,7 +21,6 @@ import (
"testing"
"k8s.io/apimachinery/pkg/util/version"
kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
)
func TestGetStaticPodDirectory(t *testing.T) {
@ -172,30 +171,6 @@ func TestEtcdSupportedVersion(t *testing.T) {
}
}
func TestGetDNSVersion(t *testing.T) {
var tests = []struct {
dns kubeadmapi.DNSAddOnType
expected string
}{
{
dns: kubeadmapi.CoreDNS,
expected: CoreDNSVersion,
},
}
for _, rt := range tests {
t.Run(string(rt.dns), func(t *testing.T) {
actualDNSVersion := GetDNSVersion(rt.dns)
if actualDNSVersion != rt.expected {
t.Errorf(
"failed GetDNSVersion:\n\texpected: %s\n\t actual: %s",
rt.expected,
actualDNSVersion,
)
}
})
}
}
func TestGetKubernetesServiceCIDR(t *testing.T) {
var tests = []struct {
svcSubnetList string

6
cmd/kubeadm/app/images/images.go
View File

@ -47,7 +47,7 @@ func GetDNSImage(cfg *kubeadmapi.ClusterConfiguration) string {
dnsImageRepository = cfg.DNS.ImageRepository
}
// DNS uses an imageTag that corresponds to the DNS version matching the Kubernetes version
dnsImageTag := constants.GetDNSVersion(cfg.DNS.Type)
dnsImageTag := constants.CoreDNSVersion
// unless an override is specified
if cfg.DNS.ImageTag != "" {
@ -99,9 +99,7 @@ func GetControlPlaneImages(cfg *kubeadmapi.ClusterConfiguration) []string {
}
// Append the appropriate DNS images
if cfg.DNS.Type == kubeadmapi.CoreDNS {
imgs = append(imgs, GetDNSImage(cfg))
}
imgs = append(imgs, GetDNSImage(cfg))
return imgs
}

8
cmd/kubeadm/app/images/images_test.go
View File

@ -208,12 +208,8 @@ func TestGetAllImages(t *testing.T) {
expect: constants.Etcd,
},
{
name: "CoreDNS image is returned",
cfg: &kubeadmapi.ClusterConfiguration{
DNS: kubeadmapi.DNS{
Type: kubeadmapi.CoreDNS,
},
},
name: "CoreDNS image is returned",
cfg: &kubeadmapi.ClusterConfiguration{},
expect: constants.CoreDNSImageName,
},
}

13
cmd/kubeadm/app/phases/addons/dns/dns.go
View File

@ -47,24 +47,23 @@ const (
)
// DeployedDNSAddon returns the type of DNS addon currently deployed
func DeployedDNSAddon(client clientset.Interface) (kubeadmapi.DNSAddOnType, string, error) {
func DeployedDNSAddon(client clientset.Interface) (string, error) {
deploymentsClient := client.AppsV1().Deployments(metav1.NamespaceSystem)
deployments, err := deploymentsClient.List(context.TODO(), metav1.ListOptions{LabelSelector: "k8s-app=kube-dns"})
if err != nil {
return "", "", errors.Wrap(err, "couldn't retrieve DNS addon deployments")
return "", errors.Wrap(err, "couldn't retrieve DNS addon deployments")
}
switch len(deployments.Items) {
case 0:
return "", "", nil
return "", nil
case 1:
addonType := kubeadmapi.CoreDNS
addonImage := deployments.Items[0].Spec.Template.Spec.Containers[0].Image
addonImageParts := strings.Split(addonImage, ":")
addonVersion := addonImageParts[len(addonImageParts)-1]
return addonType, addonVersion, nil
return addonVersion, nil
default:
return "", "", errors.Errorf("multiple DNS addon deployments found: %v", deployments.Items)
return "", errors.Errorf("multiple DNS addon deployments found: %v", deployments.Items)
}
}
@ -333,7 +332,7 @@ func GetCoreDNSInfo(client clientset.Interface) (*v1.ConfigMap, string, string,
return nil, "", "", errors.New("unable to find the CoreDNS Corefile data")
}
_, currentCoreDNSversion, err := DeployedDNSAddon(client)
currentCoreDNSversion, err := DeployedDNSAddon(client)
if err != nil {
return nil, "", "", err
}

22
cmd/kubeadm/app/phases/upgrade/compute.go
View File

@ -23,7 +23,6 @@ import (
versionutil "k8s.io/apimachinery/pkg/util/version"
clientset "k8s.io/client-go/kubernetes"
"k8s.io/klog/v2"
kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
"k8s.io/kubernetes/cmd/kubeadm/app/phases/addons/dns"
)
@ -60,8 +59,6 @@ func (u *Upgrade) CanUpgradeEtcd() bool {
type ClusterState struct {
// KubeVersion describes the version of the Kubernetes API Server, Controller Manager, Scheduler and Proxy.
KubeVersion string
// DNSType describes the type of DNS add-on used in the cluster.
DNSType kubeadmapi.DNSAddOnType
// DNSVersion describes the version of the DNS add-on.
DNSVersion string
// KubeadmVersion describes the version of the kubeadm CLI
@ -74,7 +71,7 @@ type ClusterState struct {
// GetAvailableUpgrades fetches all versions from the specified VersionGetter and computes which
// kinds of upgrades can be performed
func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesAllowed, rcUpgradesAllowed, externalEtcd bool, dnsType kubeadmapi.DNSAddOnType, client clientset.Interface, manifestsDir string) ([]Upgrade, error) {
func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesAllowed, rcUpgradesAllowed, externalEtcd bool, client clientset.Interface, manifestsDir string) ([]Upgrade, error) {
fmt.Println("[upgrade] Fetching available versions to upgrade to")
// Collect the upgrades kubeadm can do in this list
@ -119,7 +116,7 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
}
}
currentDNSType, dnsVersion, err := dns.DeployedDNSAddon(client)
dnsVersion, err := dns.DeployedDNSAddon(client)
if err != nil {
return nil, err
}
@ -127,7 +124,6 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
// Construct a descriptor for the current state of the world
beforeState := ClusterState{
KubeVersion: clusterVersionStr,
DNSType: currentDNSType,
DNSVersion: dnsVersion,
KubeadmVersion: kubeadmVersionStr,
KubeletVersions: kubeletVersions,
@ -173,8 +169,7 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
Before: beforeState,
After: ClusterState{
KubeVersion: patchVersionStr,
DNSType: dnsType,
DNSVersion: kubeadmconstants.GetDNSVersion(dnsType),
DNSVersion: kubeadmconstants.CoreDNSVersion,
KubeadmVersion: newKubeadmVer,
EtcdVersion: getSuggestedEtcdVersion(externalEtcd, patchVersionStr),
// KubeletVersions is unset here as it is not used anywhere in .After
@ -190,8 +185,7 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
Before: beforeState,
After: ClusterState{
KubeVersion: stableVersionStr,
DNSType: dnsType,
DNSVersion: kubeadmconstants.GetDNSVersion(dnsType),
DNSVersion: kubeadmconstants.CoreDNSVersion,
KubeadmVersion: stableVersionStr,
EtcdVersion: getSuggestedEtcdVersion(externalEtcd, stableVersionStr),
// KubeletVersions is unset here as it is not used anywhere in .After
@ -238,8 +232,7 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
Before: beforeState,
After: ClusterState{
KubeVersion: previousBranchLatestVersionStr,
DNSType: dnsType,
DNSVersion: kubeadmconstants.GetDNSVersion(dnsType),
DNSVersion: kubeadmconstants.CoreDNSVersion,
KubeadmVersion: previousBranchLatestVersionStr,
EtcdVersion: getSuggestedEtcdVersion(externalEtcd, previousBranchLatestVersionStr),
// KubeletVersions is unset here as it is not used anywhere in .After
@ -252,12 +245,12 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
// Default to assume that the experimental version to show is the unstable one
unstableKubeVersion := latestVersionStr
unstableKubeDNSVersion := kubeadmconstants.GetDNSVersion(dnsType)
unstableKubeDNSVersion := kubeadmconstants.CoreDNSVersion
// Ẃ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 = kubeadmconstants.GetDNSVersion(dnsType)
unstableKubeDNSVersion = kubeadmconstants.CoreDNSVersion
}
upgrades = append(upgrades, Upgrade{
@ -265,7 +258,6 @@ func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesA
Before: beforeState,
After: ClusterState{
KubeVersion: unstableKubeVersion,
DNSType: dnsType,
DNSVersion: unstableKubeDNSVersion,
KubeadmVersion: unstableKubeVersion,
EtcdVersion: getSuggestedEtcdVersion(externalEtcd, unstableKubeVersion),

61
cmd/kubeadm/app/phases/upgrade/compute_test.go
View File

@ -29,7 +29,6 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
versionutil "k8s.io/apimachinery/pkg/util/version"
clientsetfake "k8s.io/client-go/kubernetes/fake"
kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
"k8s.io/kubernetes/cmd/kubeadm/app/constants"
)
@ -123,9 +122,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
allowExperimental, allowRCs bool
errExpected bool
externalEtcd bool
beforeDNSType kubeadmapi.DNSAddOnType
beforeDNSVersion string
dnsType kubeadmapi.DNSAddOnType
}{
{
name: "no action needed, already up-to-date",
@ -137,9 +134,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
stablePatchVersion: v1Y0.String(),
stableVersion: v1Y0.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{},
allowExperimental: false,
errExpected: false,
@ -154,9 +149,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
stablePatchVersion: v1Y3.String(),
stableVersion: v1Y3.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: fmt.Sprintf("version in the v%d.%d series", v1Y0.Major(), v1Y0.Minor()),
@ -166,14 +159,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1Y1.String(): 1,
},
KubeadmVersion: v1Y2.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Y3.String(),
KubeadmVersion: v1Y3.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Y3),
},
@ -192,9 +183,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
stablePatchVersion: v1Y3.String(),
stableVersion: v1Y3.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
externalEtcd: true,
expectedUpgrades: []Upgrade{
{
@ -205,14 +194,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1Y1.String(): 1,
},
KubeadmVersion: v1Y2.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: "",
},
After: ClusterState{
KubeVersion: v1Y3.String(),
KubeadmVersion: v1Y3.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: "",
},
@ -231,9 +218,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
stablePatchVersion: v1Y3.String(),
stableVersion: v1Y3.String(),
}, ""),
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: fmt.Sprintf("version in the v%d.%d series", v1Y0.Major(), v1Y0.Minor()),
@ -243,14 +228,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1Y1.String(): 1,
},
KubeadmVersion: v1Y2.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Y3.String(),
KubeadmVersion: v1Y3.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Y3),
},
@ -269,9 +252,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
stablePatchVersion: v1Y1.String(),
stableVersion: v1Z0.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: "stable version",
@ -281,14 +262,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1Y1.String(): 1,
},
KubeadmVersion: v1Z0.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Z0.String(),
KubeadmVersion: v1Z0.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Z0),
},
@ -307,9 +286,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
stablePatchVersion: v1Y5.String(),
stableVersion: v1Z1.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: fmt.Sprintf("version in the v%d.%d series", v1Y0.Major(), v1Y0.Minor()),
@ -319,14 +296,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1Y3.String(): 1,
},
KubeadmVersion: v1Y5.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Y5.String(),
KubeadmVersion: v1Y5.String(), // Note: The kubeadm version mustn't be "downgraded" here
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Y5),
},
@ -339,14 +314,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1Y3.String(): 1,
},
KubeadmVersion: v1Y5.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Z1.String(),
KubeadmVersion: v1Z1.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Z1),
},
@ -366,9 +339,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
stableVersion: v1Y5.String(),
latestVersion: v1Z0alpha2.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{},
allowExperimental: true,
errExpected: false,
@ -384,9 +355,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
stableVersion: v1Y5.String(),
latestVersion: v1Z0alpha2.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: "experimental version",
@ -396,14 +365,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1Y5.String(): 1,
},
KubeadmVersion: v1Y5.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Z0alpha2.String(),
KubeadmVersion: v1Z0alpha2.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Z0alpha2),
},
@ -423,9 +390,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
stableVersion: v1Y5.String(),
latestVersion: v1Z0alpha2.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: "experimental version",
@ -435,14 +400,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1Y5.String(): 1,
},
KubeadmVersion: v1Y5.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Z0alpha2.String(),
KubeadmVersion: v1Z0alpha2.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Z0alpha2),
},
@ -463,9 +426,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
latestDevBranchVersion: v1Z0beta1.String(),
latestVersion: v1Y0alpha0.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: "experimental version",
@ -475,14 +436,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1X5.String(): 1,
},
KubeadmVersion: v1X5.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Z0beta1.String(),
KubeadmVersion: v1Z0beta1.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Z0beta1),
},
@ -503,9 +462,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
latestDevBranchVersion: v1Z0rc1.String(),
latestVersion: v1Y0alpha1.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: "release candidate version",
@ -515,14 +472,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1X5.String(): 1,
},
KubeadmVersion: v1X5.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Z0rc1.String(),
KubeadmVersion: v1Z0rc1.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Z0rc1),
},
@ -543,9 +498,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
latestDevBranchVersion: v1Z0rc1.String(),
latestVersion: v1Y0alpha0.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: "experimental version", // Note that this is considered an experimental version in this uncommon scenario
@ -555,14 +508,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1X5.String(): 1,
},
KubeadmVersion: v1X5.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Z0rc1.String(),
KubeadmVersion: v1Z0rc1.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Z0rc1),
},
@ -583,9 +534,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
latestDevBranchVersion: v1Z0rc1.String(),
latestVersion: v1Y0alpha1.String(),
},
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: "release candidate version",
@ -595,14 +544,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1X5.String(): 1,
},
KubeadmVersion: v1X5.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Z0rc1.String(),
KubeadmVersion: v1Z0rc1.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Z0rc1),
},
@ -615,14 +562,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1X5.String(): 1,
},
KubeadmVersion: v1X5.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Y0alpha1.String(),
KubeadmVersion: v1Y0alpha1.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Y0alpha1),
},
@ -639,9 +584,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
kubeletVersion: v1Y0.String(),
kubeadmVersion: v1Y1.String(),
}, v1Z1.String()),
beforeDNSType: kubeadmapi.CoreDNS,
beforeDNSVersion: fakeCurrentCoreDNSVersion,
dnsType: kubeadmapi.CoreDNS,
expectedUpgrades: []Upgrade{
{
Description: fmt.Sprintf("version in the v%d.%d series", v1Y0.Major(), v1Y0.Minor()),
@ -651,14 +594,12 @@ func TestGetAvailableUpgrades(t *testing.T) {
v1Y0.String(): 1,
},
KubeadmVersion: v1Y1.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: fakeCurrentCoreDNSVersion,
EtcdVersion: fakeCurrentEtcdVersion,
},
After: ClusterState{
KubeVersion: v1Z1.String(),
KubeadmVersion: v1Z1.String(),
DNSType: kubeadmapi.CoreDNS,
DNSVersion: constants.CoreDNSVersion,
EtcdVersion: getEtcdVersion(v1Z1),
},
@ -709,7 +650,7 @@ func TestGetAvailableUpgrades(t *testing.T) {
t.Fatalf("Unable to create test static pod manifest: %v", err)
}
actualUpgrades, actualErr := GetAvailableUpgrades(rt.vg, rt.allowExperimental, rt.allowRCs, rt.externalEtcd, rt.dnsType, client, manifestsDir)
actualUpgrades, actualErr := GetAvailableUpgrades(rt.vg, rt.allowExperimental, rt.allowRCs, rt.externalEtcd, client, manifestsDir)
if !reflect.DeepEqual(actualUpgrades, rt.expectedUpgrades) {
t.Errorf("failed TestGetAvailableUpgrades\n\texpected upgrades: %v\n\tgot: %v", rt.expectedUpgrades, actualUpgrades)
}

6
cmd/kubeadm/app/phases/upgrade/preflight.go
View File

@ -27,7 +27,6 @@ import (
"k8s.io/apimachinery/pkg/util/sets"
clientset "k8s.io/client-go/kubernetes"
"k8s.io/klog/v2"
kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
"k8s.io/kubernetes/cmd/kubeadm/app/phases/addons/dns"
"k8s.io/kubernetes/cmd/kubeadm/app/preflight"
@ -54,10 +53,7 @@ func (c CoreDNSCheck) Check() (warnings, errors []error) {
}
// RunCoreDNSMigrationCheck initializes checks related to CoreDNS migration.
func RunCoreDNSMigrationCheck(client clientset.Interface, ignorePreflightErrors sets.String, dnsType kubeadmapi.DNSAddOnType) error {
if dnsType != kubeadmapi.CoreDNS {
return nil
}
func RunCoreDNSMigrationCheck(client clientset.Interface, ignorePreflightErrors sets.String) error {
migrationChecks := []preflight.Checker{
&CoreDNSCheck{
name: "CoreDNSUnsupportedPlugins",