func()

in pkg/executables/govc.go [619:718]
94 lines of code
21 McCabe index (conditional complexity)

func (g *Govc) ValidateVCenterSetupMachineConfig(ctx context.Context, datacenterConfig *v1alpha1.VSphereDatacenterConfig, machineConfig *v1alpha1.VSphereMachineConfig, _ *bool) error {
	envMap, err := g.validateAndSetupCreds()
	if err != nil {
		return fmt.Errorf("failed govc validations: %v", err)
	}
	machineConfig.Spec.Datastore, err = prependPath(datastore, machineConfig.Spec.Datastore, datacenterConfig.Spec.Datacenter)
	if err != nil {
		return err
	}
	params := []string{"datastore.info", machineConfig.Spec.Datastore}
	err = g.retrier.Retry(func() error {
		_, err = g.ExecuteWithEnv(ctx, envMap, params...)
		if err != nil {
			datastorePath := filepath.Dir(machineConfig.Spec.Datastore)
			isValidDatastorePath := g.isValidPath(ctx, envMap, datastorePath)
			if isValidDatastorePath {
				leafDir := filepath.Base(machineConfig.Spec.Datastore)
				return fmt.Errorf("valid path, but '%s' is not a datastore", leafDir)
			} else {
				return fmt.Errorf("failed to get datastore: %v", err)
			}
		}
		return nil
	})
	if err != nil {
		return fmt.Errorf("failed to get datastore: %v", err)
	}
	logger.MarkPass("Datastore validated")

	if len(machineConfig.Spec.Folder) > 0 {
		machineConfig.Spec.Folder, err = prependPath(vm, machineConfig.Spec.Folder, datacenterConfig.Spec.Datacenter)
		if err != nil {
			return err
		}
		params = []string{"folder.info", machineConfig.Spec.Folder}
		err = g.retrier.Retry(func() error {
			_, err := g.ExecuteWithEnv(ctx, envMap, params...)
			if err != nil {
				err = g.createFolder(ctx, envMap, machineConfig)
				if err != nil {
					currPath := "/" + datacenterConfig.Spec.Datacenter + "/"
					dirs := strings.Split(machineConfig.Spec.Folder, "/")
					for _, dir := range dirs[2:] {
						currPath += dir + "/"
						if !g.isValidPath(ctx, envMap, currPath) {
							return fmt.Errorf("%s is an invalid intermediate directory", currPath)
						}
					}
					return err
				}
			}
			return nil
		})
		if err != nil {
			return fmt.Errorf("failed to get folder: %v", err)
		}
		logger.MarkPass("Folder validated")
	}

	var poolInfoResponse bytes.Buffer
	params = []string{"find", "-json", "/" + datacenterConfig.Spec.Datacenter, "-type", "p", "-name", filepath.Base(machineConfig.Spec.ResourcePool)}
	err = g.retrier.Retry(func() error {
		poolInfoResponse, err = g.ExecuteWithEnv(ctx, envMap, params...)
		return err
	})
	if err != nil {
		return fmt.Errorf("error getting resource pool: %v", err)
	}

	poolInfoJson := poolInfoResponse.String()
	poolInfoJson = strings.TrimSuffix(poolInfoJson, "\n")
	if poolInfoJson == "null" || poolInfoJson == "" {
		return fmt.Errorf("resource pool '%s' not found", machineConfig.Spec.ResourcePool)
	}

	poolInfo := make([]string, 0)
	if err = json.Unmarshal([]byte(poolInfoJson), &poolInfo); err != nil {
		return fmt.Errorf("failed unmarshalling govc response: %v", err)
	}

	machineConfig.Spec.ResourcePool = strings.TrimPrefix(machineConfig.Spec.ResourcePool, "*/")
	bPoolFound := false
	var foundPool string
	for _, p := range poolInfo {
		if strings.HasSuffix(p, machineConfig.Spec.ResourcePool) {
			if bPoolFound {
				return fmt.Errorf("specified resource pool '%s' maps to multiple paths within the datacenter '%s'", machineConfig.Spec.ResourcePool, datacenterConfig.Spec.Datacenter)
			}
			bPoolFound = true
			foundPool = p
		}
	}
	if !bPoolFound {
		return fmt.Errorf("resource pool '%s' not found", machineConfig.Spec.ResourcePool)
	}
	machineConfig.Spec.ResourcePool = foundPool

	logger.MarkPass("Resource pool validated")
	return nil
}