porter/internal/integrations/preview/driver_validators.go

package preview

import (
	"fmt"

	"github.com/mitchellh/mapstructure"
	"github.com/porter-dev/switchboard/pkg/types"
	"k8s.io/apimachinery/pkg/util/validation"
)

func commonValidator(resource *types.Resource) (*Source, *Target, error) {
	source := &Source{}

	err := mapstructure.Decode(resource.Source, source)

	if err != nil {
		return nil, nil, fmt.Errorf("for resource '%s': error parsing source: %w", resource.Name, err)
	}

	target := &Target{}

	err = mapstructure.Decode(resource.Target, target)

	if err != nil {
		return nil, nil, fmt.Errorf("for resource '%s': error parsing target: %w", resource.Name, err)
	}

	return source, target, nil
}

func deployDriverValidator(resource *types.Resource) error {
	source, _, err := commonValidator(resource)

	if err != nil {
		return err
	}

	if source.Name == "" {
		return fmt.Errorf("for resource '%s': source name cannot be empty", resource.Name)
	}

	if source.Repo == "" {
		source.Repo = "https://charts.getporter.dev"
	}

	if source.Repo == "https://charts.getporter.dev" {
		appConfig := &ApplicationConfig{}

		err = mapstructure.Decode(resource.Config, appConfig)

		if err != nil {
			return fmt.Errorf("for resource '%s': error parsing config: %w", resource.Name, err)
		}

		if appConfig.Build.Method == "" {
			return fmt.Errorf("for resource '%s': build method cannot be empty", resource.Name)
		} else if appConfig.Build.Method != "docker" &&
			appConfig.Build.Method != "pack" &&
			appConfig.Build.Method != "registry" {
			return fmt.Errorf("for resource '%s': build method must be one of 'docker', 'pack', or 'registry'", resource.Name)
		}

		if appConfig.Build.Method == "docker" && appConfig.Build.Dockerfile == "" {
			return fmt.Errorf("for resource '%s': dockerfile cannot be empty when using the 'docker' build method",
				resource.Name)
		} else if appConfig.Build.Method == "registry" && appConfig.Build.Image == "" {
			return fmt.Errorf("for resource '%s': image cannot be empty when using the 'registry' build method",
				resource.Name)
		}

		for _, eg := range appConfig.EnvGroups {
			if errStrs := validation.IsDNS1123Label(eg.Name); len(errStrs) > 0 {
				str := fmt.Sprintf("for resource '%s': invalid characters found in env group '%s' name:",
					resource.Name, eg.Name)
				for _, errStr := range errStrs {
					str += fmt.Sprintf("\n  * %s", errStr)
				}

				return fmt.Errorf("%s", str)
			}
		}

		if len(appConfig.Values) > 0 {
			if source.Name == "web" {
				err := validateWebChartValues(appConfig.Values)

				if err != nil {
					return fmt.Errorf("for resource '%s': error validating values for web deployment: %w",
						resource.Name, err)
				}
			} else if source.Name == "worker" {
				err := validateWorkerChartValues(appConfig.Values)

				if err != nil {
					return fmt.Errorf("for resource '%s': error validating values for worker deployment: %w",
						resource.Name, err)
				}
			} else if source.Name == "job" {
				err := validateJobChartValues(appConfig.Values)

				if err != nil {
					return fmt.Errorf("for resource '%s': error validating values for job deployment: %w",
						resource.Name, err)
				}
			}
		}
	}

	return nil
}

func buildImageDriverValidator(resource *types.Resource) error {
	_, target, err := commonValidator(resource)

	if err != nil {
		return err
	}

	if target.AppName == "" {
		return fmt.Errorf("for resource '%s': target app_name is missing", resource.Name)
	} else {
		errStrs := validation.IsDNS1123Label(target.AppName)

		if len(errStrs) > 0 {
			str := fmt.Sprintf("for resource '%s': invalid characters found in app_name:", resource.Name)
			for _, errStr := range errStrs {
				str += fmt.Sprintf("\n  * %s", errStr)
			}

			return fmt.Errorf("%s", str)
		}
	}

	driverConfig := &BuildDriverConfig{}

	err = mapstructure.Decode(resource.Config, driverConfig)

	if err != nil {
		return fmt.Errorf("for resource '%s': error parsing config: %w", resource.Name, err)
	}

	if driverConfig.Build.Method == "" {
		return fmt.Errorf("for resource '%s': build method cannot be empty", resource.Name)
	} else if driverConfig.Build.Method != "docker" &&
		driverConfig.Build.Method != "pack" &&
		driverConfig.Build.Method != "registry" {
		return fmt.Errorf("for resource '%s': build method must be one of 'docker', 'pack', or 'registry'", resource.Name)
	}

	if driverConfig.Build.Method == "docker" && driverConfig.Build.Dockerfile == "" {
		return fmt.Errorf("for resource '%s': dockerfile cannot be empty when using the 'docker' build method",
			resource.Name)
	} else if driverConfig.Build.Method == "registry" && driverConfig.Build.Image == "" {
		return fmt.Errorf("for resource '%s': image cannot be empty when using the 'registry' build method",
			resource.Name)
	}

	for _, eg := range driverConfig.EnvGroups {
		if errStrs := validation.IsDNS1123Label(eg.Name); len(errStrs) > 0 {
			str := fmt.Sprintf("for resource '%s': invalid characters found in env group '%s' name:",
				resource.Name, eg.Name)
			for _, errStr := range errStrs {
				str += fmt.Sprintf("\n  * %s", errStr)
			}

			return fmt.Errorf("%s", str)
		}
	}

	return nil
}

func pushImageDriverValidator(resource *types.Resource) error {
	_, target, err := commonValidator(resource)

	if err != nil {
		return err
	}

	if target.AppName == "" {
		return fmt.Errorf("for resource '%s': target app_name is missing", resource.Name)
	} else {
		errStrs := validation.IsDNS1123Label(target.AppName)

		if len(errStrs) > 0 {
			str := fmt.Sprintf("for resource '%s': invalid characters found in app_name:", resource.Name)
			for _, errStr := range errStrs {
				str += fmt.Sprintf("\n  * %s", errStr)
			}

			return fmt.Errorf("%s", str)
		}
	}

	driverConfig := &PushDriverConfig{}

	err = mapstructure.Decode(resource.Config, driverConfig)

	if err != nil {
		return fmt.Errorf("for resource '%s': error parsing config: %w", resource.Name, err)
	}

	if driverConfig.Push.Image == "" {
		return fmt.Errorf("for resource '%s': image cannot be empty", resource.Name)
	}

	return nil
}

func updateConfigDriverValidator(resource *types.Resource) error {
	_, target, err := commonValidator(resource)

	if err != nil {
		return err
	}

	if target.AppName == "" {
		return fmt.Errorf("for resource '%s': target app_name is missing", resource.Name)
	} else {
		errStrs := validation.IsDNS1123Label(target.AppName)

		if len(errStrs) > 0 {
			str := fmt.Sprintf("for resource '%s': invalid characters found in app_name:", resource.Name)
			for _, errStr := range errStrs {
				str += fmt.Sprintf("\n  * %s", errStr)
			}

			return fmt.Errorf("%s", str)
		}
	}

	driverConfig := &UpdateConfigDriverConfig{}

	err = mapstructure.Decode(resource.Config, driverConfig)

	if err != nil {
		return fmt.Errorf("for resource '%s': error parsing config: %w", resource.Name, err)
	}

	if driverConfig.UpdateConfig.Image == "" {
		return fmt.Errorf("for resource '%s': image cannot be empty", resource.Name)
	}

	for _, eg := range driverConfig.EnvGroups {
		if errStrs := validation.IsDNS1123Label(eg.Name); len(errStrs) > 0 {
			str := fmt.Sprintf("for resource '%s': invalid characters found in env group '%s' name:",
				resource.Name, eg.Name)
			for _, errStr := range errStrs {
				str += fmt.Sprintf("\n  * %s", errStr)
			}

			return fmt.Errorf("%s", str)
		}
	}

	return nil
}

func randomStringDriverValidator(resource *types.Resource) error {
	driverConfig := &RandomStringDriverConfig{}

	err := mapstructure.Decode(resource.Config, driverConfig)

	if err != nil {
		return fmt.Errorf("for resource '%s': error parsing config: %w", resource.Name, err)
	}

	return nil
}

func envGroupDriverValidator(resource *types.Resource) error {
	target := &Target{}

	err := mapstructure.Decode(resource.Target, target)

	if err != nil {
		return fmt.Errorf("for resource '%s': error parsing target: %w", resource.Name, err)
	}

	config := &EnvGroupDriverConfig{}

	err = mapstructure.Decode(resource.Config, config)

	if err != nil {
		return fmt.Errorf("for resource '%s': error parsing config: %w", resource.Name, err)
	}

	for _, eg := range config.EnvGroups {
		if errStrs := validation.IsDNS1123Label(eg.Name); len(errStrs) > 0 {
			str := fmt.Sprintf("for resource '%s': invalid characters found in env group '%s' name:",
				resource.Name, eg.Name)
			for _, errStr := range errStrs {
				str += fmt.Sprintf("\n  * %s", errStr)
			}

			return fmt.Errorf("%s", str)
		}
	}

	return nil
}

func osEnvDriverValidator(resource *types.Resource) error {
	return nil
}