Support Cloudstack multiple endpoint for preflight checks

pkg/dependencies/factory.go

@@ -266,6 +266,7 @@ func (f *Factory) WithProvider(clusterConfigFile string, clusterConfig *v1alpha1
 				return fmt.Errorf("unable to get machine config from file %s: %v", clusterConfigFile, err)
 			}
 
+			// map[string]*executables.Cmk and map[string]ProviderCmkClient are not compatible so we convert the map manually
 			cmkClientMap := cloudstack.CmkClientMap{}
 			for name, cmk := range f.dependencies.Cmks {
 				cmkClientMap[name] = cmk
@@ -419,7 +420,7 @@ func (f *Factory) WithCmk() *Factory {
 	f.WithExecutableBuilder().WithWriter()
 
 	f.buildSteps = append(f.buildSteps, func(ctx context.Context) error {
-		if f.dependencies.Cmks != nil {
+		if f.dependencies.Cmks != nil && len(f.dependencies.Cmks) > 0 {
 			return nil
 		}
 		f.dependencies.Cmks = map[string]*executables.Cmk{}

pkg/executables/cmk.go

@@ -262,9 +262,6 @@ func (c *Cmk) ValidateDomainPresent(ctx context.Context, domain string) (v1alpha
 
 func (c *Cmk) ValidateNetworkPresent(ctx context.Context, domainId string, network v1alpha1.CloudStackResourceIdentifier, zoneId string, account string, multipleZone bool) error {
 	command := newCmkCommand("list networks")
-	if len(network.Id) > 0 {
-		applyCmkArgs(&command, withCloudStackId(network.Id))
-	}
 	if multipleZone {
 		applyCmkArgs(&command, withCloudStackNetworkType(Shared))
 	}
@@ -432,14 +429,13 @@ func (c *Cmk) exec(ctx context.Context, args ...string) (stdout bytes.Buffer, er
 func (c *Cmk) buildCmkConfigFile() (configFile string, err error) {
 	t := templater.New(c.writer)
 
-	cloudstackPreflightTimeout := defaultCloudStackPreflightTimeout
+	c.config.Timeout = defaultCloudStackPreflightTimeout
 	if timeout, isSet := os.LookupEnv("CLOUDSTACK_PREFLIGHT_TIMEOUT"); isSet {
 		if _, err := strconv.ParseUint(timeout, 10, 16); err != nil {
 			return "", fmt.Errorf("CLOUDSTACK_PREFLIGHT_TIMEOUT must be a number: %v", err)
 		}
-		cloudstackPreflightTimeout = timeout
+		c.config.Timeout = timeout
 	}
-	c.config.Timeout = cloudstackPreflightTimeout
 	writtenFileName, err := t.WriteToFile(cmkConfigTemplate, c.config, fmt.Sprintf(cmkConfigFileNameTemplate, c.config.Name))
 	if err != nil {
 		return "", fmt.Errorf("creating file for cmk config: %v", err)

pkg/executables/cmk_test.go

@@ -518,21 +518,6 @@ func TestCmkListOperations(t *testing.T) {
 			shouldSecondCallOccur: false,
 			wantResultCount:       1,
 		},
-		{
-			testName:         "listnetworks success on id filter",
-			jsonResponseFile: "testdata/cmk_list_network_singular.json",
-			argumentsExecCall: []string{
-				"-c", configFilePath,
-				"list", "networks", fmt.Sprintf("id=\"%s\"", resourceId.Id), fmt.Sprintf("domainid=\"%s\"", domainId), fmt.Sprintf("account=\"%s\"", accountName), fmt.Sprintf("zoneid=\"%s\"", "TEST_RESOURCE"),
-			},
-			cmkFunc: func(cmk executables.Cmk, ctx context.Context) error {
-				return cmk.ValidateNetworkPresent(ctx, domainId, zones[3].Network, zones[3].Id, accountName, false)
-			},
-			cmkResponseError:      nil,
-			wantErr:               false,
-			shouldSecondCallOccur: true,
-			wantResultCount:       1,
-		},
 		{
 			testName:         "listnetworks no results",
 			jsonResponseFile: "testdata/cmk_list_empty_response.json",

pkg/providers/cloudstack/cloudstack.go

@@ -395,15 +395,15 @@ func (p *cloudstackProvider) validateClusterSpec(ctx context.Context, clusterSpe
 
 func (p *cloudstackProvider) SetupAndValidateCreateCluster(ctx context.Context, clusterSpec *cluster.Spec) error {
 	if err := p.validateEnv(ctx); err != nil {
-		return fmt.Errorf("failed setup and validations: %v", err)
+		return fmt.Errorf("validating environment variables: %v", err)
 	}
 
 	if err := p.validateClusterSpec(ctx, clusterSpec); err != nil {
-		return fmt.Errorf("failed cluster spec validation: %v", err)
+		return fmt.Errorf("validating cluster spec: %v", err)
 	}
 
 	if err := p.setupSSHAuthKeysForCreate(); err != nil {
-		return fmt.Errorf("failed setup and validations: %v", err)
+		return fmt.Errorf("setting up SSH keys: %v", err)
 	}
 
 	if clusterSpec.Cluster.IsManaged() {
@@ -434,15 +434,15 @@ func (p *cloudstackProvider) SetupAndValidateCreateCluster(ctx context.Context,
 
 func (p *cloudstackProvider) SetupAndValidateUpgradeCluster(ctx context.Context, cluster *types.Cluster, clusterSpec *cluster.Spec) error {
 	if err := p.validateEnv(ctx); err != nil {
-		return fmt.Errorf("failed setup and validations: %v", err)
+		return fmt.Errorf("validating environment variables: %v", err)
 	}
 
 	if err := p.validateClusterSpec(ctx, clusterSpec); err != nil {
-		return fmt.Errorf("failed cluster spec validation: %v", err)
+		return fmt.Errorf("validating cluster spec: %v", err)
 	}
 
 	if err := p.setupSSHAuthKeysForUpgrade(); err != nil {
-		return fmt.Errorf("failed setup and validations: %v", err)
+		return fmt.Errorf("setting up SSH keys: %v", err)
 	}
 
 	if err := p.validateMachineConfigsNameUniqueness(ctx, cluster, clusterSpec); err != nil {
@@ -454,7 +454,7 @@ func (p *cloudstackProvider) SetupAndValidateUpgradeCluster(ctx context.Context,
 func (p *cloudstackProvider) SetupAndValidateDeleteCluster(ctx context.Context, _ *types.Cluster) error {
 	err := p.validateEnv(ctx)
 	if err != nil {
-		return fmt.Errorf("failed setup and validations: %v", err)
+		return fmt.Errorf("validating environment variables: %v", err)
 	}
 	return nil
 }

pkg/providers/cloudstack/validator.go

@@ -14,8 +14,8 @@ import (
 )
 
 type Validator struct {
-	cmks              CmkClientMap
-	availabilityZones []localAvailabilityZone
+	cmks                   CmkClientMap
+	localAvailabilityZones []localAvailabilityZone
 }
 
 // Taken from https://github.com/shapeblue/cloudstack/blob/08bb4ad9fea7e422c3d3ac6d52f4670b1e89eed7/api/src/main/java/com/cloud/vm/VmDetailConstants.java
@@ -32,8 +32,8 @@ var restrictedUserCustomDetails = [...]string{
 
 func NewValidator(cmks CmkClientMap) *Validator {
 	return &Validator{
-		cmks:              cmks,
-		availabilityZones: []localAvailabilityZone{},
+		cmks:                   cmks,
+		localAvailabilityZones: []localAvailabilityZone{},
 	}
 }
 
@@ -59,25 +59,25 @@ type ProviderCmkClient interface {
 type CmkClientMap map[string]ProviderCmkClient
 
 func (v *Validator) validateCloudStackAccess(ctx context.Context, datacenterConfig *anywherev1.CloudStackDatacenterConfig) error {
-	azNamesToCheck := []string{}
+	refNamesToCheck := []string{}
 	if len(datacenterConfig.Spec.Domain) > 0 {
-		azNamesToCheck = append(azNamesToCheck, decoder.CloudStackGlobalAZ)
+		refNamesToCheck = append(refNamesToCheck, decoder.CloudStackGlobalAZ)
 	}
 	for _, az := range datacenterConfig.Spec.AvailabilityZones {
-		azNamesToCheck = append(azNamesToCheck, az.CredentialsRef)
+		refNamesToCheck = append(refNamesToCheck, az.CredentialsRef)
 	}
 
-	for _, azName := range azNamesToCheck {
-		cmk, ok := v.cmks[azName]
+	for _, refName := range refNamesToCheck {
+		cmk, ok := v.cmks[refName]
 		if !ok {
-			return fmt.Errorf("cannot find CloudStack profile for availability zone %s", azName)
+			return fmt.Errorf("cannot find CloudStack profile for credentialsRef %s", refName)
 		}
 		if err := cmk.ValidateCloudStackConnection(ctx); err != nil {
-			return fmt.Errorf("failed validating connection to cloudstack %s: %v", azName, err)
+			return fmt.Errorf("failed validating connection to cloudstack %s: %v", refName, err)
 		}
 	}
 
-	logger.MarkPass("Connected to", "servers", azNamesToCheck)
+	logger.MarkPass("Connected to", "servers", refNamesToCheck)
 	return nil
 }
 
@@ -86,22 +86,33 @@ func (v *Validator) ValidateCloudStackDatacenterConfig(ctx context.Context, data
 		return err
 	}
 
-	for _, az := range v.availabilityZones {
+	for _, az := range v.localAvailabilityZones {
+		fmt.Printf("az: %+v\n", az.CloudStackAvailabilityZone)
 		_, err := getHostnameFromUrl(az.ManagementApiEndpoint)
 		if err != nil {
 			return fmt.Errorf("checking management api endpoint: %v", err)
 		}
 
 		cmk, ok := v.cmks[az.CredentialsRef]
 		if !ok {
-			return fmt.Errorf("cannot find CloudStack profile for availability zone %s", az.CredentialsRef)
+			return fmt.Errorf("cannot find CloudStack profile named %s for availability zone %s", az.CredentialsRef, az.Name)
 		}
 		endpoint := cmk.GetManagementApiEndpoint()
 		if endpoint != az.ManagementApiEndpoint {
 			return fmt.Errorf("cloudstack secret management url (%s) differs from cluster spec management url (%s)",
 				endpoint, az.ManagementApiEndpoint)
 		}
 
+		domain, err := cmk.ValidateDomainPresent(ctx, az.Domain)
+		if err != nil {
+			return err
+		}
+		az.DomainId = domain.Id
+
+		if err := cmk.ValidateAccountPresent(ctx, az.Account, az.DomainId); err != nil {
+			return err
+		}
+
 		zoneId, err := cmk.ValidateZonePresent(ctx, az.CloudStackAvailabilityZone.Zone)
 		if err != nil {
 			return err
@@ -125,52 +136,37 @@ func (v *Validator) generateLocalAvailabilityZones(ctx context.Context, datacent
 	}
 
 	if len(datacenterConfig.Spec.Domain) > 0 {
-		cmk, ok := v.cmks[decoder.CloudStackGlobalAZ]
+		_, ok := v.cmks[decoder.CloudStackGlobalAZ]
 		if !ok {
-			return fmt.Errorf("cannot find CloudStack profile for availability zone %s", decoder.CloudStackGlobalAZ)
-		}
-		domain, err := cmk.ValidateDomainPresent(ctx, datacenterConfig.Spec.Domain)
-		if err != nil {
-			return err
-		}
-		if err := cmk.ValidateAccountPresent(ctx, datacenterConfig.Spec.Account, domain.Id); err != nil {
-			return err
+			return fmt.Errorf("cannot find CloudStack profile named %s for default availability zone", decoder.CloudStackGlobalAZ)
 		}
-		for _, zone := range datacenterConfig.Spec.Zones {
+		for index, zone := range datacenterConfig.Spec.Zones {
 			availabilityZone := localAvailabilityZone{
 				CloudStackAvailabilityZone: &anywherev1.CloudStackAvailabilityZone{
+					Name:                  fmt.Sprintf("availability-zone-%d", index),
 					CredentialsRef:        decoder.CloudStackGlobalAZ,
 					Domain:                datacenterConfig.Spec.Domain,
 					Account:               datacenterConfig.Spec.Account,
 					ManagementApiEndpoint: datacenterConfig.Spec.ManagementApiEndpoint,
 					Zone:                  zone,
 				},
-				DomainId: domain.Id,
 			}
-			v.availabilityZones = append(v.availabilityZones, availabilityZone)
+			v.localAvailabilityZones = append(v.localAvailabilityZones, availabilityZone)
 		}
 	}
 	for _, az := range datacenterConfig.Spec.AvailabilityZones {
-		cmk, ok := v.cmks[az.CredentialsRef]
+		_, ok := v.cmks[az.CredentialsRef]
 		if !ok {
-			return fmt.Errorf("cannot find CloudStack profile for availability zone %s", az.CredentialsRef)
-		}
-		domain, err := cmk.ValidateDomainPresent(ctx, az.Domain)
-		if err != nil {
-			return err
-		}
-		if err := cmk.ValidateAccountPresent(ctx, az.Account, domain.Id); err != nil {
-			return err
+			return fmt.Errorf("cannot find CloudStack profile named %s for availability zone %s", az.CredentialsRef, az.Name)
 		}
 		availabilityZone := localAvailabilityZone{
 			CloudStackAvailabilityZone: &az,
-			DomainId:                   domain.Id,
 		}
-		v.availabilityZones = append(v.availabilityZones, availabilityZone)
+		v.localAvailabilityZones = append(v.localAvailabilityZones, availabilityZone)
 	}
 
-	if len(v.availabilityZones) <= 0 {
-		return fmt.Errorf("CloudStackDatacenterConfig domain or availabilityZones is not set or is empty")
+	if len(v.localAvailabilityZones) <= 0 {
+		return fmt.Errorf("CloudStackDatacenterConfig domain or localAvailabilityZones is not set or is empty")
 	}
 	return nil
 }
@@ -286,10 +282,10 @@ func (v *Validator) validateMachineConfig(ctx context.Context, datacenterConfig
 		}
 	}
 
-	for _, az := range v.availabilityZones {
+	for _, az := range v.localAvailabilityZones {
 		cmk, ok := v.cmks[az.CredentialsRef]
 		if !ok {
-			return fmt.Errorf("cannot find CloudStack profile for availability zone %s", az.CredentialsRef)
+			return fmt.Errorf("cannot find CloudStack profile named %s for availability zone %s", az.CredentialsRef, az.Name)
 		}
 		if err := cmk.ValidateTemplatePresent(ctx, az.DomainId, az.CloudStackAvailabilityZone.Zone.Id, az.Account, machineConfig.Spec.Template); err != nil {
 			return fmt.Errorf("validating template: %v", err)