Add MachineDeployment specifier to node pool

Adds a command line flag to specify the MachineDeployment to use as a
base when creating a new node pool

Author: tenczar

cmd/cli/plugin/cluster/set_node_pool.go

@@ -17,8 +17,9 @@ import (
 )
 
 type clusterSetNodePoolCmdOptions struct {
-	FilePath  string
-	Namespace string
+	FilePath              string
+	Namespace             string
+	MachineDeploymentBase string
 }
 
 var setNodePoolOptions clusterSetNodePoolCmdOptions
@@ -32,6 +33,7 @@ var clusterSetNodePoolCmd = &cobra.Command{
 func init() {
 	clusterSetNodePoolCmd.Flags().StringVarP(&setNodePoolOptions.FilePath, "file", "f", "", "The file describing the node pool (required)")
 	clusterSetNodePoolCmd.Flags().StringVar(&setNodePoolOptions.Namespace, "namespace", "default", "The namespace the cluster is found in.")
+	clusterSetNodePoolCmd.Flags().StringVar(&setNodePoolOptions.MachineDeploymentBase, "machine-deployment-base", "", "The machine deployment to use as a base for creating a new node pool (ignored for TKGs)")
 	_ = clusterSetNodePoolCmd.MarkFlagRequired("file")
 	clusterNodePoolCmd.AddCommand(clusterSetNodePoolCmd)
 }
@@ -64,6 +66,7 @@ func SetNodePool(server *v1alpha1.Server, clusterName string) error {
 	if err = yaml.Unmarshal(fileContent, &nodePool); err != nil {
 		return errors.Wrap(err, "Could not parse file contents")
 	}
+	nodePool.MachineDeploymentBase = setNodePoolOptions.MachineDeploymentBase
 
 	options := client.SetMachineDeploymentOptions{
 		ClusterName: clusterName,

pkg/v1/tkg/client/machine_deployment.go

@@ -55,18 +55,19 @@ type DeleteMachineDeploymentOptions struct {
 
 // NodePool a struct describing a node pool
 type NodePool struct {
-	Name             string                    `yaml:"name"`
-	Replicas         *int32                    `yaml:"replicas,omitempty"`
-	AZ               string                    `yaml:"az,omitempty"`
-	NodeMachineType  string                    `yaml:"nodeMachineType,omitempty"`
-	Labels           *map[string]string        `yaml:"labels,omitempty"`
-	VSphere          VSphereNodePool           `yaml:"vsphere,omitempty"`
-	Taints           *[]corev1.Taint           `yaml:"taints,omitempty"`
-	VMClass          string                    `yaml:"vmClass,omitempty"`
-	StorageClass     string                    `yaml:"storageClass,omitempty"`
-	Volumes          *[]tkgsv1alpha2.Volume    `yaml:"volumes,omitempty"`
-	TKR              tkgsv1alpha2.TKRReference `yaml:"tkr,omitempty"`
-	NodeDrainTimeout *metav1.Duration          `yaml:"nodeDrainTimeout,omitempty"`
+	Name                  string                    `yaml:"name"`
+	Replicas              *int32                    `yaml:"replicas,omitempty"`
+	AZ                    string                    `yaml:"az,omitempty"`
+	NodeMachineType       string                    `yaml:"nodeMachineType,omitempty"`
+	Labels                *map[string]string        `yaml:"labels,omitempty"`
+	VSphere               VSphereNodePool           `yaml:"vsphere,omitempty"`
+	Taints                *[]corev1.Taint           `yaml:"taints,omitempty"`
+	VMClass               string                    `yaml:"vmClass,omitempty"`
+	StorageClass          string                    `yaml:"storageClass,omitempty"`
+	Volumes               *[]tkgsv1alpha2.Volume    `yaml:"volumes,omitempty"`
+	TKR                   tkgsv1alpha2.TKRReference `yaml:"tkr,omitempty"`
+	NodeDrainTimeout      *metav1.Duration          `yaml:"nodeDrainTimeout,omitempty"`
+	MachineDeploymentBase string                    `yaml:"machineDeploymentBase,omitempty"`
 }
 
 // VSphereNodePool a struct describing properties necessary for a node pool on vSphere
@@ -133,6 +134,13 @@ func DoSetMachineDeployment(clusterClient clusterclient.Client, options *SetMach
 			update = true
 			break
 		}
+		if workerMDs[i].Name == options.MachineDeploymentBase {
+			baseMD = workerMDs[i]
+		}
+	}
+
+	if !update && (options.MachineDeploymentBase != "" && baseMD.Name != options.MachineDeploymentBase) {
+		return errors.Errorf("unable to find base machine deployment with name %s", options.MachineDeploymentBase)
 	}
 
 	baseMD.Annotations = map[string]string{}
@@ -147,6 +155,10 @@ func DoSetMachineDeployment(clusterClient clusterclient.Client, options *SetMach
 	}
 
 	if !update {
+		if options.MachineDeploymentBase == "" {
+			log.Warningf("Using machine deployment %s as baseline for new node pool", baseMD.Name)
+		}
+
 		kcTemplateName := baseMD.Spec.Template.Spec.Bootstrap.ConfigRef.Name
 		kcTemplate, err := retrieveKubeadmConfigTemplate(clusterClient, kcTemplateName, options.Namespace)
 		if err != nil {

pkg/v1/tkg/client/machine_deployment_test.go

@@ -1229,6 +1229,15 @@ var _ = Describe("Machine Deployment", func() {
 					},
 				}
 			})
+			When("the user selected machine deployment doesn't exist", func() {
+				BeforeEach(func() {
+					clusterClient.GetMDObjectForClusterReturns([]capi.MachineDeployment{md1}, nil)
+					options.MachineDeploymentBase = "test-cluster-md-3"
+				})
+				It("should return an error", func() {
+					Expect(err).Should(MatchError("unable to find base machine deployment with name test-cluster-md-3"))
+				})
+			})
 			Context("vSphere machine deployment", func() {
 				var vSphereMachineTemplate vsphere.VSphereMachineTemplate
 				BeforeEach(func() {
@@ -1402,7 +1411,12 @@ var _ = Describe("Machine Deployment", func() {
 							},
 						},
 					}
-					clusterClient.GetMDObjectForClusterReturns([]capi.MachineDeployment{md1}, nil)
+					md3.Spec.Template.Labels = map[string]string{
+						"existing": "md3",
+					}
+					md3.Spec.Template.Spec.InfrastructureRef.Kind = constants.AWSMachineTemplate
+					md3.Spec.Selector.MatchLabels = map[string]string{}
+					clusterClient.GetMDObjectForClusterReturns([]capi.MachineDeployment{md1, md3}, nil)
 					awsMachineTemplate = aws.AWSMachineTemplate{
 						ObjectMeta: metav1.ObjectMeta{
 							Name: "test-cluster-np-1-mt",
@@ -1438,7 +1452,38 @@ var _ = Describe("Machine Deployment", func() {
 				clusterClient.CreateResourceReturnsOnCall(0, nil)
 				clusterClient.CreateResourceReturnsOnCall(1, nil)
 				clusterClient.CreateNamespaceReturnsOnCall(2, nil)
-				When("Machine Deployment creates successfully", func() {
+				When("Machine Deployment creates successfully from default md", func() {
+					It("should properly set all values for created resources", func() {
+						Expect(err).ToNot(HaveOccurred())
+						Expect(clusterClient.CreateResourceCallCount()).To(Equal(3))
+
+						obj, _, _, _ := clusterClient.CreateResourceArgsForCall(0)
+						kct := obj.(*v1beta1.KubeadmConfigTemplate)
+						Expect(kct.Annotations).To(Equal(map[string]string{}))
+						Expect(kct.ResourceVersion).To(Equal(""))
+						Expect(kct.Name).To(Equal("test-cluster-np-2-kct"))
+						Expect(kct.Spec.Template.Spec.JoinConfiguration.NodeRegistration.KubeletExtraArgs["node-labels"]).To(Equal("key1=value1,key2=value2"))
+
+						obj, _, _, _ = clusterClient.CreateResourceArgsForCall(1)
+						mt := obj.(*aws.AWSMachineTemplate)
+						Expect(mt.Name).To(Equal("test-cluster-np-2-mt"))
+						Expect(mt.Annotations).To(Equal(map[string]string{}))
+						Expect(mt.ResourceVersion).To(Equal(""))
+						Expect(mt.Spec.Template.Spec.InstanceType).To(Equal(options.NodeMachineType))
+
+						obj, _, _, _ = clusterClient.CreateResourceArgsForCall(2)
+						md := obj.(*capi.MachineDeployment)
+						Expect(md.Name).To(Equal("test-cluster-np-2"))
+						Expect(md.Annotations).To(Equal(map[string]string{}))
+						Expect(md.ResourceVersion).To(Equal(""))
+						Expect(*md.Spec.Template.Spec.FailureDomain).To(Equal(options.AZ))
+						Expect(md.Spec.Replicas).To(Equal(options.Replicas))
+					})
+				})
+				When("Machine Deployment creates successfully from user selected md", func() {
+					BeforeEach(func() {
+						options.MachineDeploymentBase = "test-cluster-np-3"
+					})
 					It("should properly set all values for created resources", func() {
 						Expect(err).ToNot(HaveOccurred())
 						Expect(clusterClient.CreateResourceCallCount()).To(Equal(3))
@@ -1464,6 +1509,7 @@ var _ = Describe("Machine Deployment", func() {
 						Expect(md.ResourceVersion).To(Equal(""))
 						Expect(*md.Spec.Template.Spec.FailureDomain).To(Equal(options.AZ))
 						Expect(md.Spec.Replicas).To(Equal(options.Replicas))
+						Expect(md.Spec.Template.Labels).To(HaveKeyWithValue("existing", "md3"))
 					})
 				})
 			})