func ValidateFlags()

in pkg/app/app.go [57:143]
70 lines of code
25 McCabe index (conditional complexity)

func ValidateFlags(args []string, cmd *cobra.Command, opt *kobject.ConvertOptions) {
	if opt.OutFile == "-" {
		opt.ToStdout = true
		opt.OutFile = ""
	}

	// Get the provider
	provider := cmd.Flags().Lookup("provider").Value.String()
	log.Debugf("Checking validation of provider: %s", provider)

	// OpenShift specific flags
	deploymentConfig := cmd.Flags().Lookup("deployment-config").Changed
	buildRepo := cmd.Flags().Lookup("build-repo").Changed
	buildBranch := cmd.Flags().Lookup("build-branch").Changed

	// Kubernetes specific flags
	chart := cmd.Flags().Lookup("chart").Changed
	daemonSet := cmd.Flags().Lookup("daemon-set").Changed
	replicationController := cmd.Flags().Lookup("replication-controller").Changed
	deployment := cmd.Flags().Lookup("deployment").Changed

	// Get the controller
	controller := opt.Controller
	log.Debugf("Checking validation of controller: %s", controller)

	// Check validations against provider flags
	switch {
	case provider == ProviderOpenshift:
		if chart {
			log.Fatalf("--chart, -c is a Kubernetes only flag")
		}
		if daemonSet {
			log.Fatalf("--daemon-set is a Kubernetes only flag")
		}
		if replicationController {
			log.Fatalf("--replication-controller is a Kubernetes only flag")
		}
		if deployment {
			log.Fatalf("--deployment, -d is a Kubernetes only flag")
		}
		if controller == "daemonset" || controller == "replicationcontroller" || controller == "deployment" {
			log.Fatalf("--controller= daemonset, replicationcontroller or deployment is a Kubernetes only flag")
		}
	case provider == ProviderKubernetes:
		if deploymentConfig {
			log.Fatalf("--deployment-config is an OpenShift only flag")
		}
		if buildRepo {
			log.Fatalf("--build-repo is an Openshift only flag")
		}
		if buildBranch {
			log.Fatalf("--build-branch is an Openshift only flag")
		}
		if controller == "deploymentconfig" {
			log.Fatalf("--controller=deploymentConfig is an OpenShift only flag")
		}
	}

	// Standard checks regardless of provider
	if len(opt.OutFile) != 0 && opt.ToStdout {
		log.Fatalf("Error: --out and --stdout can't be set at the same time")
	}

	if opt.CreateChart && opt.ToStdout {
		log.Fatalf("Error: chart cannot be generated when --stdout is specified")
	}

	if opt.Replicas < 0 {
		log.Fatalf("Error: --replicas cannot be negative")
	}

	if len(args) != 0 {
		log.Fatal("Unknown Argument(s): ", strings.Join(args, ","))
	}

	if opt.GenerateJSON && opt.GenerateYaml {
		log.Fatalf("YAML and JSON format cannot be provided at the same time")
	}

	if _, ok := kubernetes.ValidVolumeSet[opt.Volumes]; !ok {
		validVolumesTypes := make([]string, 0)
		for validVolumeType := range kubernetes.ValidVolumeSet {
			validVolumesTypes = append(validVolumesTypes, fmt.Sprintf("'%s'", validVolumeType))
		}
		log.Fatal("Unknown Volume type: ", opt.Volumes, ", possible values are: ", strings.Join(validVolumesTypes, " "))
	}
}