SPLAT-1142: generate control plane machineset

Author: rvanderp3

pkg/asset/machines/master.go

@@ -473,7 +473,7 @@ func (m *Master) Generate(dependencies asset.Parents) error {
 		pool.Platform.VSphere = &mpool
 		templateName := clusterID.InfraID + "-rhcos"
 
-		machines, err = vsphere.Machines(clusterID.InfraID, ic, &pool, templateName, "master", masterUserDataSecretName)
+		machines, controlPlaneMachineSet, err = vsphere.Machines(clusterID.InfraID, ic, &pool, templateName, "master", masterUserDataSecretName)
 		if err != nil {
 			return errors.Wrap(err, "failed to create master machine objects")
 		}

pkg/asset/machines/vsphere/machines.go

@@ -10,35 +10,37 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 
+	v1 "github.com/openshift/api/config/v1"
+	machinev1 "github.com/openshift/api/machine/v1"
 	machineapi "github.com/openshift/api/machine/v1beta1"
 	"github.com/openshift/installer/pkg/types"
 	"github.com/openshift/installer/pkg/types/vsphere"
 )
 
 // Machines returns a list of machines for a machinepool.
-func Machines(clusterID string, config *types.InstallConfig, pool *types.MachinePool, osImage, role, userDataSecret string) ([]machineapi.Machine, error) {
+func Machines(clusterID string, config *types.InstallConfig, pool *types.MachinePool, osImage, role, userDataSecret string) ([]machineapi.Machine, *machinev1.ControlPlaneMachineSet, error) {
 	if configPlatform := config.Platform.Name(); configPlatform != vsphere.Name {
-		return nil, fmt.Errorf("non vsphere configuration: %q", configPlatform)
+		return nil, nil, fmt.Errorf("non vsphere configuration: %q", configPlatform)
 	}
 	if poolPlatform := pool.Platform.Name(); poolPlatform != vsphere.Name {
-		return nil, fmt.Errorf("non-VSphere machine-pool: %q", poolPlatform)
+		return nil, nil, fmt.Errorf("non-VSphere machine-pool: %q", poolPlatform)
 	}
 
 	var failureDomain vsphere.FailureDomain
 	var machines []machineapi.Machine
 	platform := config.Platform.VSphere
 	mpool := pool.Platform.VSphere
-	replicas := int64(1)
+	replicas := int32(1)
 
 	numOfZones := len(mpool.Zones)
 
 	zones, err := getDefinedZonesFromTopology(platform)
 	if err != nil {
-		return machines, err
+		return machines, nil, err
 	}
 
 	if pool.Replicas != nil {
-		replicas = *pool.Replicas
+		replicas = int32(*pool.Replicas)
 	}
 
 	// Create hosts to populate from.  Copying so we can remove without changing original
@@ -53,7 +55,11 @@ func Machines(clusterID string, config *types.InstallConfig, pool *types.Machine
 		}
 	}
 
-	for idx := int64(0); idx < replicas; idx++ {
+	failureDomains := []machinev1.VSphereFailureDomain{}
+
+	vsphereMachineProvider := &machineapi.VSphereMachineProviderSpec{}
+
+	for idx := int32(0); idx < replicas; idx++ {
 		logrus.Debugf("Creating %v machine %v", role, idx)
 		var host *vsphere.Host
 		desiredZone := mpool.Zones[int(idx)%numOfZones]
@@ -66,7 +72,7 @@ func Machines(clusterID string, config *types.InstallConfig, pool *types.Machine
 		logrus.Debugf("Desired zone: %v", desiredZone)
 
 		if _, exists := zones[desiredZone]; !exists {
-			return nil, errors.Errorf("zone [%s] specified by machinepool is not defined", desiredZone)
+			return nil, nil, errors.Errorf("zone [%s] specified by machinepool is not defined", desiredZone)
 		}
 
 		failureDomain = zones[desiredZone]
@@ -77,20 +83,26 @@ func Machines(clusterID string, config *types.InstallConfig, pool *types.Machine
 			"machine.openshift.io/cluster-api-machine-type": role,
 		}
 
+		failureDomains = append(failureDomains, machinev1.VSphereFailureDomain{
+			Name: failureDomain.Name,
+		})
+
 		osImageForZone := failureDomain.Topology.Template
 		if failureDomain.Topology.Template == "" {
 			osImageForZone = fmt.Sprintf("%s-%s-%s", osImage, failureDomain.Region, failureDomain.Zone)
 		}
 
 		vcenter, err := getVCenterFromServerName(failureDomain.Server, platform)
 		if err != nil {
-			return nil, errors.Wrap(err, "unable to find vCenter in failure domains")
+			return nil, nil, errors.Wrap(err, "unable to find vCenter in failure domains")
 		}
 		provider, err := provider(clusterID, vcenter, failureDomain, mpool, osImageForZone, userDataSecret)
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to create provider")
+			return nil, nil, errors.Wrap(err, "failed to create provider")
 		}
 
+		vsphereMachineProvider = provider
+
 		// Apply static IP if configured
 		applyNetworkConfig(host, provider)
 
@@ -113,7 +125,61 @@ func Machines(clusterID string, config *types.InstallConfig, pool *types.Machine
 		}
 		machines = append(machines, machine)
 	}
-	return machines, nil
+
+	// when multiple zones are defined, network and workspace are derived from the topology
+	if len(failureDomains) > 1 {
+		vsphereMachineProvider.Network = machineapi.NetworkSpec{}
+		vsphereMachineProvider.Workspace = &machineapi.Workspace{}
+		vsphereMachineProvider.Template = ""
+	}
+
+	controlPlaneMachineSet := &machinev1.ControlPlaneMachineSet{
+		TypeMeta: metav1.TypeMeta{
+			APIVersion: "machine.openshift.io/v1",
+			Kind:       "ControlPlaneMachineSet",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "openshift-machine-api",
+			Name:      "cluster",
+			Labels: map[string]string{
+				"machine.openshift.io/cluster-api-cluster": clusterID,
+			},
+		},
+		Spec: machinev1.ControlPlaneMachineSetSpec{
+			Replicas: &replicas,
+			State:    machinev1.ControlPlaneMachineSetStateActive,
+			Selector: metav1.LabelSelector{
+				MatchLabels: map[string]string{
+					"machine.openshift.io/cluster-api-machine-role": role,
+					"machine.openshift.io/cluster-api-machine-type": role,
+					"machine.openshift.io/cluster-api-cluster":      clusterID,
+				},
+			},
+			Template: machinev1.ControlPlaneMachineSetTemplate{
+				MachineType: machinev1.OpenShiftMachineV1Beta1MachineType,
+				OpenShiftMachineV1Beta1Machine: &machinev1.OpenShiftMachineV1Beta1MachineTemplate{
+					FailureDomains: machinev1.FailureDomains{
+						Platform: v1.VSpherePlatformType,
+						VSphere:  failureDomains,
+					},
+					ObjectMeta: machinev1.ControlPlaneMachineSetTemplateObjectMeta{
+						Labels: map[string]string{
+							"machine.openshift.io/cluster-api-cluster":      clusterID,
+							"machine.openshift.io/cluster-api-machine-role": role,
+							"machine.openshift.io/cluster-api-machine-type": role,
+						},
+					},
+					Spec: machineapi.MachineSpec{
+						ProviderSpec: machineapi.ProviderSpec{
+							Value: &runtime.RawExtension{Object: vsphereMachineProvider},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	return machines, controlPlaneMachineSet, nil
 }
 
 // applyNetworkConfig this function will apply the static ip configuration to the networkDevice

pkg/asset/machines/vsphere/machines_test.go

@@ -378,7 +378,7 @@ func TestConfigMasters(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.testCase, func(t *testing.T) {
-			machines, err := Machines(clusterID, tc.installConfig, tc.machinePool, "", "", "")
+			machines, _, err := Machines(clusterID, tc.installConfig, tc.machinePool, "", "", "")
 			assertOnUnexpectedErrorState(t, tc.expectedError, err)
 
 			if len(tc.workspaces) > 0 {
@@ -449,7 +449,7 @@ func TestHostsToMachines(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.testCase, func(t *testing.T) {
-			machines, err := Machines(clusterID, tc.installConfig, tc.machinePool, "", tc.role, "")
+			machines, _, err := Machines(clusterID, tc.installConfig, tc.machinePool, "", tc.role, "")
 			assertOnUnexpectedErrorState(t, tc.expectedError, err)
 
 			// Check machine counts

pkg/asset/machines/worker.go

@@ -627,7 +627,7 @@ func (w *Worker) Generate(dependencies asset.Parents) error {
 				logrus.Debug("Generating worker machines with static IPs.")
 				templateName := clusterID.InfraID + "-rhcos"
 
-				machines, err = vsphere.Machines(clusterID.InfraID, ic, &pool, templateName, "worker", workerUserDataSecretName)
+				machines, _, err = vsphere.Machines(clusterID.InfraID, ic, &pool, templateName, "worker", workerUserDataSecretName)
 				if err != nil {
 					return errors.Wrap(err, "failed to create worker machine objects")
 				}