refactor: adopt improvements from gardener/gardener provider local

Author: Roncossek

pkg/admission/validator/cloudprofile.go

@@ -22,17 +22,17 @@ import (
 
 // NewCloudProfileValidator returns a new instance of a cloud profile validator.
 func NewCloudProfileValidator(mgr manager.Manager) extensionswebhook.Validator {
-	return &cloudProfile{
+	return &cloudProfileValidator{
 		decoder: serializer.NewCodecFactory(mgr.GetScheme(), serializer.EnableStrict).UniversalDecoder(),
 	}
 }
 
-type cloudProfile struct {
+type cloudProfileValidator struct {
 	decoder runtime.Decoder
 }
 
 // Validate validates the given cloud profile objects.
-func (cp *cloudProfile) Validate(_ context.Context, newObj, _ client.Object) error {
+func (cp *cloudProfileValidator) Validate(_ context.Context, newObj, _ client.Object) error {
 	cloudProfile, ok := newObj.(*core.CloudProfile)
 	if !ok {
 		return fmt.Errorf("wrong object type %T", newObj)
@@ -45,13 +45,13 @@ func (cp *cloudProfile) Validate(_ context.Context, newObj, _ client.Object) err
 
 	cpConfig, err := decodeCloudProfileConfig(cp.decoder, cloudProfile.Spec.ProviderConfig)
 	if err != nil {
-		return err
+		return fmt.Errorf("could not decode providerConfig of CloudProfile %q: %w", cloudProfile.Name, err)
 	}
 
-	capabilitiesDefinitions, err := gardencorev1beta1helper.ConvertV1beta1CapabilityDefinitions(cloudProfile.Spec.MachineCapabilities)
+	capabilityDefinitions, err := gardencorev1beta1helper.ConvertV1beta1CapabilityDefinitions(cloudProfile.Spec.MachineCapabilities)
 	if err != nil {
 		return field.InternalError(field.NewPath("spec").Child("machineCapabilities"), err)
 	}
 
-	return awsvalidation.ValidateCloudProfileConfig(cpConfig, cloudProfile.Spec.MachineImages, capabilitiesDefinitions, providerConfigPath).ToAggregate()
+	return awsvalidation.ValidateCloudProfileConfig(cpConfig, cloudProfile.Spec.MachineImages, capabilityDefinitions, providerConfigPath).ToAggregate()
 }

pkg/admission/validator/namespacedcloudprofile.go

@@ -42,25 +42,25 @@ type namespacedCloudProfile struct {
 
 // Validate validates the given NamespacedCloudProfile objects.
 func (p *namespacedCloudProfile) Validate(ctx context.Context, newObj, _ client.Object) error {
-	profile, ok := newObj.(*core.NamespacedCloudProfile)
+	cloudProfile, ok := newObj.(*core.NamespacedCloudProfile)
 	if !ok {
 		return fmt.Errorf("wrong object type %T", newObj)
 	}
 
-	if profile.DeletionTimestamp != nil {
+	if cloudProfile.DeletionTimestamp != nil {
 		return nil
 	}
 
-	cpConfig := &api.CloudProfileConfig{}
-	if profile.Spec.ProviderConfig != nil {
+	cloudProfileConfig := &api.CloudProfileConfig{}
+	if cloudProfile.Spec.ProviderConfig != nil {
 		var err error
-		cpConfig, err = decodeCloudProfileConfig(p.decoder, profile.Spec.ProviderConfig)
+		cloudProfileConfig, err = decodeCloudProfileConfig(p.decoder, cloudProfile.Spec.ProviderConfig)
 		if err != nil {
-			return err
+			return fmt.Errorf("could not decode providerConfig of NamespacedCloudProfile for '%s': %w", cloudProfile.Name, err)
 		}
 	}
 
-	parentCloudProfile := profile.Spec.Parent
+	parentCloudProfile := cloudProfile.Spec.Parent
 	if parentCloudProfile.Kind != constants.CloudProfileReferenceKindCloudProfile {
 		return fmt.Errorf("parent reference must be of kind CloudProfile (unsupported kind: %s)", parentCloudProfile.Kind)
 	}
@@ -69,16 +69,7 @@ func (p *namespacedCloudProfile) Validate(ctx context.Context, newObj, _ client.
 		return err
 	}
 
-	return p.validateNamespacedCloudProfileProviderConfig(cpConfig, profile.Spec, parentProfile.Spec).ToAggregate()
-}
-
-// validateNamespacedCloudProfileProviderConfig validates the CloudProfileConfig passed with a NamespacedCloudProfile.
-func (p *namespacedCloudProfile) validateNamespacedCloudProfileProviderConfig(providerConfig *api.CloudProfileConfig, profileSpec core.NamespacedCloudProfileSpec, parentSpec gardencorev1beta1.CloudProfileSpec) field.ErrorList {
-	allErrs := field.ErrorList{}
-
-	allErrs = append(allErrs, p.validateMachineImages(providerConfig, profileSpec.MachineImages, parentSpec)...)
-
-	return allErrs
+	return p.validateMachineImages(cloudProfileConfig, cloudProfile.Spec.MachineImages, parentProfile.Spec).ToAggregate()
 }
 
 func (p *namespacedCloudProfile) validateMachineImages(providerConfig *api.CloudProfileConfig, machineImages []core.MachineImage, parentSpec gardencorev1beta1.CloudProfileSpec) field.ErrorList {
@@ -87,7 +78,7 @@ func (p *namespacedCloudProfile) validateMachineImages(providerConfig *api.Cloud
 	machineImagesPath := field.NewPath("spec.providerConfig.machineImages")
 	for i, machineImage := range providerConfig.MachineImages {
 		idxPath := machineImagesPath.Index(i)
-		allErrs = append(allErrs, validation.ValidateProviderMachineImage(idxPath, machineImage, parentSpec.MachineCapabilities)...)
+		allErrs = append(allErrs, validation.ValidateProviderMachineImage(machineImage, parentSpec.MachineCapabilities, idxPath)...)
 	}
 
 	profileImages := gutil.NewCoreImagesContext(machineImages)

pkg/apis/aws/helper/helper.go

@@ -94,7 +94,7 @@ func FindImageInCloudProfile(
 	}
 	machineImages := cloudProfileConfig.MachineImages
 
-	capabilitySet, err := findCapabilitySetFromMachineImages(machineImages, name, version, region, arch, machineCapabilities, capabilityDefinitions)
+	capabilitySet, err := findMachineImageFlavor(machineImages, name, version, region, arch, machineCapabilities, capabilityDefinitions)
 	if err != nil {
 		return nil, fmt.Errorf("could not find an AMI for region %q, image %q, version %q that supports %v: %w", region, name, version, machineCapabilities, err)
 	}
@@ -135,7 +135,7 @@ func FindImageInWorkerStatus(machineImages []api.MachineImage, name string, vers
 	return nil, fmt.Errorf("no machine image found for image %q with version %q and capabilities %v", name, version, machineCapabilities)
 }
 
-func findCapabilitySetFromMachineImages(
+func findMachineImageFlavor(
 	machineImages []api.MachineImages,
 	imageName, imageVersion, region string,
 	arch *string,
@@ -166,7 +166,7 @@ func findCapabilitySetFromMachineImages(
 			filteredCapabilityFlavors := filterCapabilityFlavorsByRegion(version.CapabilityFlavors, region)
 			bestMatch, err := worker.FindBestImageFlavor(filteredCapabilityFlavors, machineCapabilities, capabilityDefinitions)
 			if err != nil {
-				return nil, fmt.Errorf("could not determine best capabilitySet %w", err)
+				return nil, fmt.Errorf("could not determine best flavor %w", err)
 			}
 
 			return bestMatch, nil