kubeadm cleanup: master -> control-plane (cont.4)

Author: vanduc95

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

@@ -101,15 +101,15 @@ func kubeDNSAddon(cfg *kubeadmapi.ClusterConfiguration, client clientset.Interfa
 	}
 
 	dnsDeploymentBytes, err := kubeadmutil.ParseTemplate(KubeDNSDeployment,
-		struct{ DeploymentName, KubeDNSImage, DNSMasqImage, SidecarImage, DNSBindAddr, DNSProbeAddr, DNSDomain, MasterTaintKey string }{
-			DeploymentName: kubeadmconstants.KubeDNSDeploymentName,
-			KubeDNSImage:   images.GetDNSImage(cfg, kubeadmconstants.KubeDNSKubeDNSImageName),
-			DNSMasqImage:   images.GetDNSImage(cfg, kubeadmconstants.KubeDNSDnsMasqNannyImageName),
-			SidecarImage:   images.GetDNSImage(cfg, kubeadmconstants.KubeDNSSidecarImageName),
-			DNSBindAddr:    dnsBindAddr,
-			DNSProbeAddr:   dnsProbeAddr,
-			DNSDomain:      cfg.Networking.DNSDomain,
-			MasterTaintKey: kubeadmconstants.LabelNodeRoleMaster,
+		struct{ DeploymentName, KubeDNSImage, DNSMasqImage, SidecarImage, DNSBindAddr, DNSProbeAddr, DNSDomain, ControlPlaneTaintKey string }{
+			DeploymentName:       kubeadmconstants.KubeDNSDeploymentName,
+			KubeDNSImage:         images.GetDNSImage(cfg, kubeadmconstants.KubeDNSKubeDNSImageName),
+			DNSMasqImage:         images.GetDNSImage(cfg, kubeadmconstants.KubeDNSDnsMasqNannyImageName),
+			SidecarImage:         images.GetDNSImage(cfg, kubeadmconstants.KubeDNSSidecarImageName),
+			DNSBindAddr:          dnsBindAddr,
+			DNSProbeAddr:         dnsProbeAddr,
+			DNSDomain:            cfg.Networking.DNSDomain,
+			ControlPlaneTaintKey: kubeadmconstants.LabelNodeRoleMaster,
 		})
 	if err != nil {
 		return errors.Wrap(err, "error when parsing kube-dns deployment template")
@@ -157,10 +157,10 @@ func createKubeDNSAddon(deploymentBytes, serviceBytes []byte, client clientset.I
 
 func coreDNSAddon(cfg *kubeadmapi.ClusterConfiguration, client clientset.Interface) error {
 	// Get the YAML manifest
-	coreDNSDeploymentBytes, err := kubeadmutil.ParseTemplate(CoreDNSDeployment, struct{ DeploymentName, Image, MasterTaintKey string }{
-		DeploymentName: kubeadmconstants.CoreDNSDeploymentName,
-		Image:          images.GetDNSImage(cfg, kubeadmconstants.CoreDNSImageName),
-		MasterTaintKey: kubeadmconstants.LabelNodeRoleMaster,
+	coreDNSDeploymentBytes, err := kubeadmutil.ParseTemplate(CoreDNSDeployment, struct{ DeploymentName, Image, ControlPlaneTaintKey string }{
+		DeploymentName:       kubeadmconstants.CoreDNSDeploymentName,
+		Image:                images.GetDNSImage(cfg, kubeadmconstants.CoreDNSImageName),
+		ControlPlaneTaintKey: kubeadmconstants.LabelNodeRoleMaster,
 	})
 	if err != nil {
 		return errors.Wrap(err, "error when parsing CoreDNS deployment template")

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

@@ -98,15 +98,15 @@ func TestCompileManifests(t *testing.T) {
 	}{
 		{
 			manifest: KubeDNSDeployment,
-			data: struct{ DeploymentName, KubeDNSImage, DNSMasqImage, SidecarImage, DNSBindAddr, DNSProbeAddr, DNSDomain, MasterTaintKey string }{
-				DeploymentName: "foo",
-				KubeDNSImage:   "foo",
-				DNSMasqImage:   "foo",
-				SidecarImage:   "foo",
-				DNSBindAddr:    "foo",
-				DNSProbeAddr:   "foo",
-				DNSDomain:      "foo",
-				MasterTaintKey: "foo",
+			data: struct{ DeploymentName, KubeDNSImage, DNSMasqImage, SidecarImage, DNSBindAddr, DNSProbeAddr, DNSDomain, ControlPlaneTaintKey string }{
+				DeploymentName:       "foo",
+				KubeDNSImage:         "foo",
+				DNSMasqImage:         "foo",
+				SidecarImage:         "foo",
+				DNSBindAddr:          "foo",
+				DNSProbeAddr:         "foo",
+				DNSDomain:            "foo",
+				ControlPlaneTaintKey: "foo",
 			},
 			expected: true,
 		},
@@ -119,10 +119,10 @@ func TestCompileManifests(t *testing.T) {
 		},
 		{
 			manifest: CoreDNSDeployment,
-			data: struct{ DeploymentName, Image, MasterTaintKey string }{
-				DeploymentName: "foo",
-				Image:          "foo",
-				MasterTaintKey: "foo",
+			data: struct{ DeploymentName, Image, ControlPlaneTaintKey string }{
+				DeploymentName:       "foo",
+				Image:                "foo",
+				ControlPlaneTaintKey: "foo",
 			},
 			expected: true,
 		},
@@ -436,23 +436,23 @@ func TestDeploymentsHaveSystemClusterCriticalPriorityClassName(t *testing.T) {
 	}{
 		{
 			manifest: KubeDNSDeployment,
-			data: struct{ DeploymentName, KubeDNSImage, DNSMasqImage, SidecarImage, DNSBindAddr, DNSProbeAddr, DNSDomain, MasterTaintKey string }{
-				DeploymentName: "foo",
-				KubeDNSImage:   "foo",
-				DNSMasqImage:   "foo",
-				SidecarImage:   "foo",
-				DNSBindAddr:    "foo",
-				DNSProbeAddr:   "foo",
-				DNSDomain:      "foo",
-				MasterTaintKey: "foo",
+			data: struct{ DeploymentName, KubeDNSImage, DNSMasqImage, SidecarImage, DNSBindAddr, DNSProbeAddr, DNSDomain, ControlPlaneTaintKey string }{
+				DeploymentName:       "foo",
+				KubeDNSImage:         "foo",
+				DNSMasqImage:         "foo",
+				SidecarImage:         "foo",
+				DNSBindAddr:          "foo",
+				DNSProbeAddr:         "foo",
+				DNSDomain:            "foo",
+				ControlPlaneTaintKey: "foo",
 			},
 		},
 		{
 			manifest: CoreDNSDeployment,
-			data: struct{ DeploymentName, Image, MasterTaintKey string }{
-				DeploymentName: "foo",
-				Image:          "foo",
-				MasterTaintKey: "foo",
+			data: struct{ DeploymentName, Image, ControlPlaneTaintKey string }{
+				DeploymentName:       "foo",
+				Image:                "foo",
+				ControlPlaneTaintKey: "foo",
 			},
 		},
 	}

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

@@ -77,7 +77,7 @@ spec:
             path: /readiness
             port: 8081
             scheme: HTTP
-          # we poll on pod startup for the Kubernetes master service and
+          # we poll on pod startup for the Kubernetes control-plane service and
           # only setup the /readiness HTTP server once that's available.
           initialDelaySeconds: 3
           timeoutSeconds: 5
@@ -173,7 +173,7 @@ spec:
       tolerations:
       - key: CriticalAddonsOnly
         operator: Exists
-      - key: {{ .MasterTaintKey }}
+      - key: {{ .ControlPlaneTaintKey }}
         effect: NoSchedule
 `
 
@@ -241,7 +241,7 @@ spec:
       tolerations:
       - key: CriticalAddonsOnly
         operator: Exists
-      - key: {{ .MasterTaintKey }}
+      - key: {{ .ControlPlaneTaintKey }}
         effect: NoSchedule
       nodeSelector:
         beta.kubernetes.io/os: linux

cmd/kubeadm/app/phases/addons/proxy/manifests.go

@@ -33,7 +33,7 @@ data:
     clusters:
     - cluster:
         certificate-authority: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
-        server: {{ .MasterEndpoint }}
+        server: {{ .ControlPlaneEndpoint }}
       name: default
     contexts:
     - context:

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

@@ -67,15 +67,15 @@ func EnsureProxyAddon(cfg *kubeadmapi.ClusterConfiguration, localEndpoint *kubea
 	var proxyConfigMapBytes, proxyDaemonSetBytes []byte
 	proxyConfigMapBytes, err = kubeadmutil.ParseTemplate(KubeProxyConfigMap19,
 		struct {
-			MasterEndpoint    string
-			ProxyConfig       string
-			ProxyConfigMap    string
-			ProxyConfigMapKey string
+			ControlPlaneEndpoint string
+			ProxyConfig          string
+			ProxyConfigMap       string
+			ProxyConfigMapKey    string
 		}{
-			MasterEndpoint:    controlPlaneEndpoint,
-			ProxyConfig:       prefixBytes.String(),
-			ProxyConfigMap:    constants.KubeProxyConfigMap,
-			ProxyConfigMapKey: constants.KubeProxyConfigMapKey,
+			ControlPlaneEndpoint: controlPlaneEndpoint,
+			ProxyConfig:          prefixBytes.String(),
+			ProxyConfigMap:       constants.KubeProxyConfigMap,
+			ProxyConfigMapKey:    constants.KubeProxyConfigMapKey,
 		})
 	if err != nil {
 		return errors.Wrap(err, "error when parsing kube-proxy configmap template")

cmd/kubeadm/app/phases/addons/proxy/proxy_test.go

@@ -103,12 +103,12 @@ func TestCompileManifests(t *testing.T) {
 		{
 			manifest: KubeProxyConfigMap19,
 			data: struct {
-				MasterEndpoint, ProxyConfig, ProxyConfigMap, ProxyConfigMapKey string
+				ControlPlaneEndpoint, ProxyConfig, ProxyConfigMap, ProxyConfigMapKey string
 			}{
-				MasterEndpoint:    "foo",
-				ProxyConfig:       "  bindAddress: 0.0.0.0\n  clusterCIDR: 192.168.1.1\n  enableProfiling: false",
-				ProxyConfigMap:    "bar",
-				ProxyConfigMapKey: "baz",
+				ControlPlaneEndpoint: "foo",
+				ProxyConfig:          "  bindAddress: 0.0.0.0\n  clusterCIDR: 192.168.1.1\n  enableProfiling: false",
+				ProxyConfigMap:       "bar",
+				ProxyConfigMapKey:    "baz",
 			},
 			expected: true,
 		},
@@ -140,7 +140,7 @@ func TestEnsureProxyAddon(t *testing.T) {
 	const (
 		NoError SimulatedError = iota
 		ServiceAccountError
-		InvalidMasterEndpoint
+		InvalidControlPlaneEndpoint
 		IPv6SetBindAddress
 	)
 
@@ -177,7 +177,7 @@ func TestEnsureProxyAddon(t *testing.T) {
 		// Create a fake client and set up default test configuration
 		client := clientsetfake.NewSimpleClientset()
 		// TODO: Consider using a YAML file instead for this that makes it possible to specify YAML documents for the ComponentConfigs
-		masterConfig := &kubeadmapiv1beta1.InitConfiguration{
+		controlPlaneConfig := &kubeadmapiv1beta1.InitConfiguration{
 			LocalAPIEndpoint: kubeadmapiv1beta1.APIEndpoint{
 				AdvertiseAddress: "1.2.3.4",
 				BindPort:         1234,
@@ -197,19 +197,19 @@ func TestEnsureProxyAddon(t *testing.T) {
 			client.PrependReactor("create", "serviceaccounts", func(action core.Action) (bool, runtime.Object, error) {
 				return true, nil, apierrors.NewUnauthorized("")
 			})
-		case InvalidMasterEndpoint:
-			masterConfig.LocalAPIEndpoint.AdvertiseAddress = "1.2.3"
+		case InvalidControlPlaneEndpoint:
+			controlPlaneConfig.LocalAPIEndpoint.AdvertiseAddress = "1.2.3"
 		case IPv6SetBindAddress:
-			masterConfig.LocalAPIEndpoint.AdvertiseAddress = "1:2::3:4"
-			masterConfig.Networking.PodSubnet = "2001:101::/96"
+			controlPlaneConfig.LocalAPIEndpoint.AdvertiseAddress = "1:2::3:4"
+			controlPlaneConfig.Networking.PodSubnet = "2001:101::/96"
 		}
 
-		intMaster, err := configutil.DefaultedInitConfiguration(masterConfig)
+		intControlPlane, err := configutil.DefaultedInitConfiguration(controlPlaneConfig)
 		if err != nil {
 			t.Errorf("test failed to convert external to internal version")
 			break
 		}
-		intMaster.ComponentConfigs.KubeProxy = &kubeproxyconfig.KubeProxyConfiguration{
+		intControlPlane.ComponentConfigs.KubeProxy = &kubeproxyconfig.KubeProxyConfiguration{
 			BindAddress:        "",
 			HealthzBindAddress: "0.0.0.0:10256",
 			MetricsBindAddress: "127.0.0.1:10249",
@@ -222,11 +222,11 @@ func TestEnsureProxyAddon(t *testing.T) {
 			},
 		}
 		// Run dynamic defaulting again as we changed the internal cfg
-		if err := configutil.SetInitDynamicDefaults(intMaster); err != nil {
+		if err := configutil.SetInitDynamicDefaults(intControlPlane); err != nil {
 			t.Errorf("test failed to set dynamic defaults: %v", err)
 			break
 		}
-		err = EnsureProxyAddon(&intMaster.ClusterConfiguration, &intMaster.LocalAPIEndpoint, client)
+		err = EnsureProxyAddon(&intControlPlane.ClusterConfiguration, &intControlPlane.LocalAPIEndpoint, client)
 
 		// Compare actual to expected errors
 		actErr := "No error"
@@ -244,17 +244,17 @@ func TestEnsureProxyAddon(t *testing.T) {
 				expErr,
 				actErr)
 		}
-		if intMaster.ComponentConfigs.KubeProxy.BindAddress != tc.expBindAddr {
+		if intControlPlane.ComponentConfigs.KubeProxy.BindAddress != tc.expBindAddr {
 			t.Errorf("%s test failed, expected: %s, got: %s",
 				tc.name,
 				tc.expBindAddr,
-				intMaster.ComponentConfigs.KubeProxy.BindAddress)
+				intControlPlane.ComponentConfigs.KubeProxy.BindAddress)
 		}
-		if intMaster.ComponentConfigs.KubeProxy.ClusterCIDR != tc.expClusterCIDR {
+		if intControlPlane.ComponentConfigs.KubeProxy.ClusterCIDR != tc.expClusterCIDR {
 			t.Errorf("%s test failed, expected: %s, got: %s",
 				tc.name,
 				tc.expClusterCIDR,
-				intMaster.ComponentConfigs.KubeProxy.ClusterCIDR)
+				intControlPlane.ComponentConfigs.KubeProxy.ClusterCIDR)
 		}
 	}
 }

cmd/kubeadm/app/phases/kubeconfig/kubeconfig.go

@@ -136,15 +136,15 @@ func getKubeConfigSpecs(cfg *kubeadmapi.InitConfiguration) (map[string]*kubeConf
 		return nil, errors.Wrap(err, "couldn't create a kubeconfig; the CA files couldn't be loaded")
 	}
 
-	masterEndpoint, err := kubeadmutil.GetControlPlaneEndpoint(cfg.ControlPlaneEndpoint, &cfg.LocalAPIEndpoint)
+	controlPlaneEndpoint, err := kubeadmutil.GetControlPlaneEndpoint(cfg.ControlPlaneEndpoint, &cfg.LocalAPIEndpoint)
 	if err != nil {
 		return nil, err
 	}
 
 	var kubeConfigSpec = map[string]*kubeConfigSpec{
 		kubeadmconstants.AdminKubeConfigFileName: {
 			CACert:     caCert,
-			APIServer:  masterEndpoint,
+			APIServer:  controlPlaneEndpoint,
 			ClientName: "kubernetes-admin",
 			ClientCertAuth: &clientCertAuth{
 				CAKey:         caKey,
@@ -153,7 +153,7 @@ func getKubeConfigSpecs(cfg *kubeadmapi.InitConfiguration) (map[string]*kubeConf
 		},
 		kubeadmconstants.KubeletKubeConfigFileName: {
 			CACert:     caCert,
-			APIServer:  masterEndpoint,
+			APIServer:  controlPlaneEndpoint,
 			ClientName: fmt.Sprintf("%s%s", kubeadmconstants.NodesUserPrefix, cfg.NodeRegistration.Name),
 			ClientCertAuth: &clientCertAuth{
 				CAKey:         caKey,
@@ -162,15 +162,15 @@ func getKubeConfigSpecs(cfg *kubeadmapi.InitConfiguration) (map[string]*kubeConf
 		},
 		kubeadmconstants.ControllerManagerKubeConfigFileName: {
 			CACert:     caCert,
-			APIServer:  masterEndpoint,
+			APIServer:  controlPlaneEndpoint,
 			ClientName: kubeadmconstants.ControllerManagerUser,
 			ClientCertAuth: &clientCertAuth{
 				CAKey: caKey,
 			},
 		},
 		kubeadmconstants.SchedulerKubeConfigFileName: {
 			CACert:     caCert,
-			APIServer:  masterEndpoint,
+			APIServer:  controlPlaneEndpoint,
 			ClientName: kubeadmconstants.SchedulerUser,
 			ClientCertAuth: &clientCertAuth{
 				CAKey: caKey,
@@ -290,14 +290,14 @@ func WriteKubeConfigWithClientCert(out io.Writer, cfg *kubeadmapi.InitConfigurat
 		return errors.Wrap(err, "couldn't create a kubeconfig; the CA files couldn't be loaded")
 	}
 
-	masterEndpoint, err := kubeadmutil.GetControlPlaneEndpoint(cfg.ControlPlaneEndpoint, &cfg.LocalAPIEndpoint)
+	controlPlaneEndpoint, err := kubeadmutil.GetControlPlaneEndpoint(cfg.ControlPlaneEndpoint, &cfg.LocalAPIEndpoint)
 	if err != nil {
 		return err
 	}
 
 	spec := &kubeConfigSpec{
 		ClientName: clientName,
-		APIServer:  masterEndpoint,
+		APIServer:  controlPlaneEndpoint,
 		CACert:     caCert,
 		ClientCertAuth: &clientCertAuth{
 			CAKey:         caKey,
@@ -317,14 +317,14 @@ func WriteKubeConfigWithToken(out io.Writer, cfg *kubeadmapi.InitConfiguration,
 		return errors.Wrap(err, "couldn't create a kubeconfig; the CA files couldn't be loaded")
 	}
 
-	masterEndpoint, err := kubeadmutil.GetControlPlaneEndpoint(cfg.ControlPlaneEndpoint, &cfg.LocalAPIEndpoint)
+	controlPlaneEndpoint, err := kubeadmutil.GetControlPlaneEndpoint(cfg.ControlPlaneEndpoint, &cfg.LocalAPIEndpoint)
 	if err != nil {
 		return err
 	}
 
 	spec := &kubeConfigSpec{
 		ClientName: clientName,
-		APIServer:  masterEndpoint,
+		APIServer:  controlPlaneEndpoint,
 		CACert:     caCert,
 		TokenAuth: &tokenAuth{
 			Token: token,

cmd/kubeadm/app/phases/kubeconfig/kubeconfig_test.go

@@ -162,11 +162,11 @@ func TestGetKubeConfigSpecs(t *testing.T) {
 			}
 
 			// Asserts InitConfiguration values injected into spec
-			masterEndpoint, err := kubeadmutil.GetControlPlaneEndpoint(cfg.ControlPlaneEndpoint, &cfg.LocalAPIEndpoint)
+			controlPlaneEndpoint, err := kubeadmutil.GetControlPlaneEndpoint(cfg.ControlPlaneEndpoint, &cfg.LocalAPIEndpoint)
 			if err != nil {
 				t.Error(err)
 			}
-			if spec.APIServer != masterEndpoint {
+			if spec.APIServer != controlPlaneEndpoint {
 				t.Errorf("getKubeConfigSpecs didn't injected cfg.APIServer endpoint into spec for %s", assertion.kubeConfigFile)
 			}
 

cmd/kubeadm/app/phases/markcontrolplane/markcontrolplane.go

@@ -39,7 +39,7 @@ func MarkControlPlane(client clientset.Interface, controlPlaneName string, taint
 	}
 
 	return apiclient.PatchNode(client, controlPlaneName, func(n *v1.Node) {
-		markMasterNode(n, taints)
+		markControlPlaneNode(n, taints)
 	})
 }
 
@@ -53,7 +53,7 @@ func taintExists(taint v1.Taint, taints []v1.Taint) bool {
 	return false
 }
 
-func markMasterNode(n *v1.Node, taints []v1.Taint) {
+func markControlPlaneNode(n *v1.Node, taints []v1.Taint) {
 	n.ObjectMeta.Labels[constants.LabelNodeRoleMaster] = ""
 
 	for _, nt := range n.Spec.Taints {