diff --git a/cli/command/command.go b/cli/command/command.go deleted file mode 100644 index 703ca406..00000000 --- a/cli/command/command.go +++ /dev/null @@ -1,260 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors All rights reserved. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package command - -import ( - "fmt" - "strings" - - "github.com/Sirupsen/logrus" - "github.com/kubernetes-incubator/kompose/cli/app" - "github.com/urfave/cli" -) - -// Hook for erroring and exit out on warning -type errorOnWarningHook struct{} - -// array consisting of our common conversion flags that will get passed along -// for the autocomplete aspect -var ( - commonConvertFlagsList = []string{"out", "replicas", "yaml", "stdout", "emptyvols"} -) - -func (errorOnWarningHook) Levels() []logrus.Level { - return []logrus.Level{logrus.WarnLevel} -} - -func (errorOnWarningHook) Fire(entry *logrus.Entry) error { - logrus.Fatalln(entry.Message) - return nil -} - -// BeforeApp is an action that is executed before any cli command. -func BeforeApp(c *cli.Context) error { - - if c.GlobalBool("verbose") { - logrus.SetLevel(logrus.DebugLevel) - } else if c.GlobalBool("suppress-warnings") { - logrus.SetLevel(logrus.ErrorLevel) - } else if c.GlobalBool("error-on-warning") { - hook := errorOnWarningHook{} - logrus.AddHook(hook) - } - - // First command added was dummy convert command so removing it - c.App.Commands = c.App.Commands[1:] - provider := strings.ToLower(c.GlobalString("provider")) - switch provider { - case "kubernetes": - c.App.Commands = append(c.App.Commands, ConvertKubernetesCommand()) - case "openshift": - c.App.Commands = append(c.App.Commands, ConvertOpenShiftCommand()) - default: - logrus.Fatalf("Unknown provider. Supported providers are kubernetes and openshift.") - } - - return nil -} - -// When user tries out `kompose -h`, the convert option should be visible -// so adding a dummy `convert` command, real convert commands depending on Providers -// mentioned are added in `BeforeApp` function -func ConvertCommandDummy() cli.Command { - command := cli.Command{ - Name: "convert", - Usage: fmt.Sprintf("Convert Docker Compose file (e.g. %s) to Kubernetes/OpenShift objects", app.DefaultComposeFile), - } - return command -} - -// Generate the Bash completion flag taking the common flags plus whatever is -// passed into the function to correspond to the primary command specific args -func generateBashCompletion(args []string) { - commonArgs := []string{"bundle", "file", "suppress-warnings", "verbose", "error-on-warning", "provider"} - flags := append(commonArgs, args...) - - for _, f := range flags { - fmt.Printf("--%s\n", f) - } -} - -// ConvertKubernetesCommand defines the kompose convert subcommand for Kubernetes provider -func ConvertKubernetesCommand() cli.Command { - command := cli.Command{ - Name: "convert", - Usage: fmt.Sprintf("Convert Docker Compose file (e.g. %s) to Kubernetes objects", app.DefaultComposeFile), - Action: func(c *cli.Context) { - app.Convert(c) - }, - BashComplete: func(c *cli.Context) { - flags := []string{"chart", "deployment", "daemonset", "replicationcontroller"} - generateBashCompletion(append(flags, commonConvertFlagsList...)) - }, - Flags: []cli.Flag{ - cli.BoolFlag{ - Name: "chart,c", - Usage: "Create a Helm chart for converted objects", - }, - cli.BoolFlag{ - Name: "deployment,d", - Usage: "Generate a Kubernetes deployment object (default on)", - }, - cli.BoolFlag{ - Name: "daemonset,ds", - Usage: "Generate a Kubernetes daemonset object", - }, - cli.BoolFlag{ - Name: "replicationcontroller,rc", - Usage: "Generate a Kubernetes replication controller object", - }, - }, - } - command.Flags = append(command.Flags, commonConvertFlags()...) - return command -} - -// ConvertOpenShiftCommand defines the kompose convert subcommand for OpenShift provider -func ConvertOpenShiftCommand() cli.Command { - command := cli.Command{ - Name: "convert", - Usage: fmt.Sprintf("Convert Docker Compose file (e.g. %s) to OpenShift objects", app.DefaultComposeFile), - Action: func(c *cli.Context) { - app.Convert(c) - }, - BashComplete: func(c *cli.Context) { - flags := []string{"deploymentconfig"} - generateBashCompletion(append(flags, commonConvertFlagsList...)) - }, - Flags: []cli.Flag{ - cli.BoolFlag{ - Name: "deploymentconfig,dc", - Usage: "Generate a OpenShift DeploymentConfig object", - }, - }, - } - command.Flags = append(command.Flags, commonConvertFlags()...) - return command -} - -func commonConvertFlags() []cli.Flag { - return []cli.Flag{ - cli.StringFlag{ - Name: "out,o", - Usage: "Specify path to a file or a directory to save generated objects into. If path is a directory, the objects are stored in that directory. If path is a file, then objects are stored in that single file. File is created if it does not exist.", - EnvVar: "OUTPUT_FILE", - }, - cli.IntFlag{ - Name: "replicas", - Value: 1, - Usage: "Specify the number of replicas in the generated resource spec (default 1)", - }, - cli.BoolFlag{ - Name: "yaml, y", - Usage: "Generate resource file in yaml format", - }, - cli.BoolFlag{ - Name: "stdout", - Usage: "Print converted objects to stdout", - }, - cli.BoolFlag{ - Name: "emptyvols", - Usage: "Use Empty Volumes. Don't generate PVCs", - }, - } -} - -// UpCommand defines the kompose up subcommand. -func UpCommand() cli.Command { - return cli.Command{ - Name: "up", - Usage: "Deploy your Dockerized application to Kubernetes (default: creating Kubernetes deployment and service)", - Action: func(c *cli.Context) { - app.Up(c) - }, - BashComplete: func(c *cli.Context) { - flags := []string{"emptyvols"} - generateBashCompletion(flags) - }, - Flags: []cli.Flag{ - cli.BoolFlag{ - Name: "emptyvols", - Usage: "Use Empty Volumes. Don't generate PVCs", - }, - }, - } -} - -// DownCommand defines the kompose down subcommand. -func DownCommand() cli.Command { - return cli.Command{ - Name: "down", - Usage: "Delete instantiated services/deployments from kubernetes", - Action: func(c *cli.Context) { - app.Down(c) - }, - BashComplete: func(c *cli.Context) { - flags := []string{"emptyvols"} - generateBashCompletion(flags) - }, - Flags: []cli.Flag{ - cli.BoolFlag{ - Name: "emptyvols", - Usage: "Use Empty Volumes. Don't generate PVCs", - }, - }, - } -} - -// CommonFlags defines the flags that are in common for all subcommands. -func CommonFlags() []cli.Flag { - return []cli.Flag{ - cli.StringFlag{ - Name: "bundle,dab", - Usage: "Specify a Distributed Application Bundle (DAB) file", - EnvVar: "DAB_FILE", - }, - - cli.StringFlag{ - Name: "file,f", - Usage: fmt.Sprintf("Specify an alternative compose file (default: %s)", app.DefaultComposeFile), - Value: app.DefaultComposeFile, - EnvVar: "COMPOSE_FILE", - }, - // creating a flag to suppress warnings - cli.BoolFlag{ - Name: "suppress-warnings", - Usage: "Suppress all warnings", - }, - // creating a flag to show all kinds of warnings - cli.BoolFlag{ - Name: "verbose", - Usage: "Show all type of logs", - }, - // flag to treat any warning as error - cli.BoolFlag{ - Name: "error-on-warning", - Usage: "Treat any warning as error", - }, - // mention the end provider - cli.StringFlag{ - Name: "provider", - Usage: "Generate artifacts for this provider", - Value: app.DefaultProvider, - EnvVar: "PROVIDER", - }, - } -} diff --git a/cmd/convert.go b/cmd/convert.go new file mode 100644 index 00000000..87b24d01 --- /dev/null +++ b/cmd/convert.go @@ -0,0 +1,129 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "github.com/kubernetes-incubator/kompose/pkg/app" + "github.com/kubernetes-incubator/kompose/pkg/kobject" + "github.com/spf13/cobra" + "github.com/spf13/viper" + "strings" +) + +var ( + ConvertSource, ConvertOut string + ConvertChart, ConvertDeployment, ConvertDaemonSet bool + ConvertReplicationController, ConvertYaml, ConvertStdout bool + ConvertEmptyVols, ConvertDeploymentConfig bool + ConvertReplicas int + ConvertOpt kobject.ConvertOptions +) + +var ConvertProvider string = GlobalProvider + +var convertCmd = &cobra.Command{ + Use: "convert [file]", + Short: "Convert a Docker Compose file", + PreRun: func(cmd *cobra.Command, args []string) { + + // Create the Convert Options. + ConvertOpt = kobject.ConvertOptions{ + ToStdout: ConvertStdout, + CreateChart: ConvertChart, + GenerateYaml: ConvertYaml, + Replicas: ConvertReplicas, + InputFile: GlobalFile, + OutFile: ConvertOut, + Provider: strings.ToLower(GlobalProvider), + CreateD: ConvertDeployment, + CreateDS: ConvertDaemonSet, + CreateRC: ConvertReplicationController, + CreateDeploymentConfig: ConvertDeploymentConfig, + EmptyVols: ConvertEmptyVols, + } + + // Validate before doing anything else. Use "bundle" if passed in. + app.ValidateFlags(GlobalBundle, args, cmd, &ConvertOpt) + }, + Run: func(cmd *cobra.Command, args []string) { + + app.Convert(ConvertOpt) + }, +} + +func init() { + + // Automatically grab environment variables + viper.AutomaticEnv() + + // Kubernetes only + convertCmd.Flags().BoolVarP(&ConvertChart, "chart", "c", false, "Create a Helm chart for converted objects") + convertCmd.Flags().BoolVar(&ConvertDaemonSet, "daemon-set", false, "Generate a Kubernetes daemonset object") + convertCmd.Flags().BoolVarP(&ConvertDeployment, "deployment", "d", false, "Generate a Kubernetes deployment object") + convertCmd.Flags().BoolVar(&ConvertReplicationController, "replication-controller", false, "Generate a Kubernetes replication controller object") + convertCmd.Flags().MarkHidden("chart") + convertCmd.Flags().MarkHidden("daemon-set") + convertCmd.Flags().MarkHidden("replication-controller") + convertCmd.Flags().MarkHidden("deployment") + + // OpenShift only + convertCmd.Flags().BoolVar(&ConvertDeploymentConfig, "deployment-config", true, "Generate an OpenShift deploymentconfig object") + convertCmd.Flags().MarkHidden("deployment-config") + + // Standard between the two + convertCmd.Flags().BoolVarP(&ConvertYaml, "yaml", "y", false, "Generate resource files into yaml format") + convertCmd.Flags().BoolVar(&ConvertStdout, "stdout", false, "Print converted objects to stdout") + convertCmd.Flags().BoolVar(&ConvertEmptyVols, "emptyvols", false, "Use Empty Volumes. Do not generate PVCs") + convertCmd.Flags().StringVarP(&ConvertOut, "out", "o", "", "Specify a file name to save objects to") + convertCmd.Flags().IntVar(&ConvertReplicas, "replicas", 1, "Specify the number of repliaces in the generate resource spec") + + // In order to 'separate' both OpenShift and Kubernetes only flags. A custom help page is created + customHelp := `Usage:{{if .Runnable}} + {{if .HasAvailableFlags}}{{appendIfNotPresent .UseLine "[flags]"}}{{else}}{{.UseLine}}{{end}}{{end}}{{if .HasAvailableSubCommands}} + {{ .CommandPath}} [command]{{end}}{{if gt .Aliases 0}} + +Aliases: + {{.NameAndAliases}} +{{end}}{{if .HasExample}} + +Examples: +{{ .Example }}{{end}}{{ if .HasAvailableSubCommands}} +Available Commands:{{range .Commands}}{{if .IsAvailableCommand}} + {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableLocalFlags}} + +Resource Flags: + -c, --chart Create a Helm chart for converted objects + --daemon-set Generate a Kubernetes daemonset object + -d, --deployment Generate a Kubernetes deployment object + --deployment-config Generate an OpenShift deployment config object + --replication-controller Generate a Kubernetes replication controller object + +Flags: +{{.LocalFlags.FlagUsages | trimRightSpace}}{{end}}{{ if .HasAvailableInheritedFlags}} + +Global Flags: +{{.InheritedFlags.FlagUsages | trimRightSpace}}{{end}}{{if .HasHelpSubCommands}} + +Additional help topics:{{range .Commands}}{{if .IsHelpCommand}} + {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableSubCommands }} +Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}} +` + // Set the help template + add the command to root + convertCmd.SetHelpTemplate(customHelp) + + RootCmd.AddCommand(convertCmd) +} diff --git a/cmd/down.go b/cmd/down.go new file mode 100644 index 00000000..9881c1bc --- /dev/null +++ b/cmd/down.go @@ -0,0 +1,59 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "strings" + + "github.com/kubernetes-incubator/kompose/pkg/app" + "github.com/kubernetes-incubator/kompose/pkg/kobject" + "github.com/spf13/cobra" +) + +var ( + DownReplicas int + DownEmptyVols bool + DownOpt kobject.ConvertOptions +) + +var downCmd = &cobra.Command{ + Use: "down", + Short: "Delete instantiated services/deployments from kubernetes", + Long: `Delete instantiated services/deployments from kubernetes. (default "kubernetes")`, + PreRun: func(cmd *cobra.Command, args []string) { + + // Create the Convert options. + DownOpt = kobject.ConvertOptions{ + Replicas: DownReplicas, + InputFile: GlobalFile, + Provider: strings.ToLower(GlobalProvider), + EmptyVols: DownEmptyVols, + } + + // Validate before doing anything else. Use "bundle" if passed in. + app.ValidateFlags(GlobalBundle, args, cmd, &DownOpt) + }, + Run: func(cmd *cobra.Command, args []string) { + app.Down(DownOpt) + }, +} + +func init() { + downCmd.Flags().BoolVar(&DownEmptyVols, "emptyvols", false, "Use Empty Volumes. Do not generate PVCs") + downCmd.Flags().IntVar(&DownReplicas, "replicas", 1, "Specify the number of repliaces in the generate resource spec") + RootCmd.AddCommand(downCmd) +} diff --git a/cmd/root.go b/cmd/root.go new file mode 100644 index 00000000..373377aa --- /dev/null +++ b/cmd/root.go @@ -0,0 +1,92 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "fmt" + "os" + "strings" + + "github.com/Sirupsen/logrus" + "github.com/spf13/cobra" +) + +// Logrus hooks + +// Hook for erroring and exit out on warning +type errorOnWarningHook struct{} + +func (errorOnWarningHook) Levels() []logrus.Level { + return []logrus.Level{logrus.WarnLevel} +} + +func (errorOnWarningHook) Fire(entry *logrus.Entry) error { + logrus.Fatalln(entry.Message) + return nil +} + +var ( + GlobalBundle, GlobalFile, GlobalProvider string + GlobalVerbose, GlobalSuppressWarnings, GlobalErrorOnWarning bool +) + +var RootCmd = &cobra.Command{ + Use: "kompose", + Short: "A tool helping Docker Compose users move to Kubernetes", + Long: `Kompose is a tool to help users who are familiar with docker-compose move to Kubernetes.`, + // PersitentPreRun will be "inherited" by all children and ran before *every* command unless + // the child has overridden the functionality. This functionality was implemented to check / modify + // all global flag calls regardless of app call. + PersistentPreRun: func(cmd *cobra.Command, args []string) { + + // Add extra logging when verbosity is passed + if GlobalVerbose { + logrus.SetLevel(logrus.DebugLevel) + } + + // Set the appropriate suppress warnings and error on warning flags + if GlobalSuppressWarnings { + logrus.SetLevel(logrus.ErrorLevel) + } else if GlobalErrorOnWarning { + hook := errorOnWarningHook{} + logrus.AddHook(hook) + } + + // Error out of the user has not chosen Kubernetes or OpenShift + provider := strings.ToLower(GlobalProvider) + if provider != "kubernetes" && provider != "openshift" { + logrus.Fatalf("%s is an unsupported provider. Supported providers are: 'kubernetes', 'openshift'.", GlobalProvider) + } + + }, +} + +func Execute() { + if err := RootCmd.Execute(); err != nil { + fmt.Println(err) + os.Exit(-1) + } +} + +func init() { + RootCmd.PersistentFlags().BoolVarP(&GlobalVerbose, "verbose", "v", false, "verbose output") + RootCmd.PersistentFlags().BoolVar(&GlobalSuppressWarnings, "suppress-warnings", false, "Suppress all warnings") + RootCmd.PersistentFlags().BoolVar(&GlobalErrorOnWarning, "error-on-warning", false, "Treat any warning as an error") + RootCmd.PersistentFlags().StringVarP(&GlobalFile, "file", "f", "docker-compose.yml", "Specify an alternative compose file") + RootCmd.PersistentFlags().StringVarP(&GlobalBundle, "bundle", "b", "", "Specify a Distributed Application GlobalBundle (DAB) file") + RootCmd.PersistentFlags().StringVar(&GlobalProvider, "provider", "kubernetes", "Specify a provider. Kubernetes or OpenShift.") +} diff --git a/cmd/up.go b/cmd/up.go new file mode 100644 index 00000000..75434a42 --- /dev/null +++ b/cmd/up.go @@ -0,0 +1,59 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "strings" + + "github.com/kubernetes-incubator/kompose/pkg/app" + "github.com/kubernetes-incubator/kompose/pkg/kobject" + "github.com/spf13/cobra" +) + +var ( + UpReplicas int + UpEmptyVols bool + UpOpt kobject.ConvertOptions +) + +var upCmd = &cobra.Command{ + Use: "up", + Short: "Deploy your Dockerized application to a container orchestrator.", + Long: `Deploy your Dockerized application to a container orchestrator. (default "kubernetes")`, + PreRun: func(cmd *cobra.Command, args []string) { + + // Create the Convert options. + UpOpt = kobject.ConvertOptions{ + Replicas: UpReplicas, + InputFile: GlobalFile, + Provider: strings.ToLower(GlobalProvider), + EmptyVols: UpEmptyVols, + } + + // Validate before doing anything else. Use "bundle" if passed in. + app.ValidateFlags(GlobalBundle, args, cmd, &UpOpt) + }, + Run: func(cmd *cobra.Command, args []string) { + app.Up(UpOpt) + }, +} + +func init() { + upCmd.Flags().BoolVar(&UpEmptyVols, "emptyvols", false, "Use Empty Volumes. Do not generate PVCs") + upCmd.Flags().IntVar(&UpReplicas, "replicas", 1, "Specify the number of repliaces in the generate resource spec") + RootCmd.AddCommand(upCmd) +} diff --git a/version/version.go b/cmd/version.go similarity index 62% rename from version/version.go rename to cmd/version.go index 7e4411e3..73e65c0c 100644 --- a/version/version.go +++ b/cmd/version.go @@ -14,12 +14,27 @@ See the License for the specific language governing permissions and limitations under the License. */ -package version +package cmd + +import ( + "fmt" + "github.com/spf13/cobra" +) var ( - // VERSION should be updated by hand at each release - VERSION = "0.1.2" - - // GITCOMMIT will be overwritten automatically by the build system + VERSION = "0.1.2" GITCOMMIT = "HEAD" ) + +// versionCmd represents the version command +var versionCmd = &cobra.Command{ + Use: "version", + Short: "Print the version of Kompose", + Run: func(cmd *cobra.Command, args []string) { + fmt.Println(VERSION + " (" + GITCOMMIT + ")") + }, +} + +func init() { + RootCmd.AddCommand(versionCmd) +} diff --git a/main.go b/main.go index c3ef520c..520f606d 100644 --- a/main.go +++ b/main.go @@ -16,37 +16,8 @@ limitations under the License. package main -import ( - "os" - - "github.com/kubernetes-incubator/kompose/cli/command" - "github.com/kubernetes-incubator/kompose/version" - "github.com/urfave/cli" -) +import "github.com/kubernetes-incubator/kompose/cmd" func main() { - app := cli.NewApp() - app.Name = "kompose" - app.Usage = "A tool helping Docker Compose users move to Kubernetes." - app.Version = version.VERSION + " (" + version.GITCOMMIT + ")" - app.Author = "Kompose Contributors" - app.Email = "https://github.com/kubernetes-incubator/kompose" - app.EnableBashCompletion = true - app.Before = command.BeforeApp - app.Flags = append(command.CommonFlags()) - app.Commands = []cli.Command{ - // NOTE: Always add this in first, because this dummy command will be removed later - // in command.BeforeApp function and provider specific command will be added - command.ConvertCommandDummy(), - // command.ConvertKubernetesCommand or command.ConvertOpenShiftCommand - // is added depending on provider mentioned. - - command.UpCommand(), - command.DownCommand(), - // TODO: enable these commands and update docs once we fix them - //command.PsCommand(), - //command.ScaleCommand(), - } - - app.Run(os.Args) + cmd.Execute() } diff --git a/cli/app/app.go b/pkg/app/app.go similarity index 77% rename from cli/app/app.go rename to pkg/app/app.go index bed8bde2..7fae0c41 100644 --- a/cli/app/app.go +++ b/pkg/app/app.go @@ -21,7 +21,7 @@ import ( "strings" "github.com/Sirupsen/logrus" - "github.com/urfave/cli" + "github.com/spf13/cobra" // install kubernetes api _ "k8s.io/kubernetes/pkg/api/install" @@ -46,13 +46,51 @@ const ( var inputFormat = "compose" -func validateFlags(c *cli.Context, opt *kobject.ConvertOptions) { +func ValidateFlags(bundle string, args []string, cmd *cobra.Command, opt *kobject.ConvertOptions) { + + // Check to see if the "file" has changed from the default flag value + isFileSet := cmd.Flags().Lookup("file").Changed if opt.OutFile == "-" { opt.ToStdout = true opt.OutFile = "" } + // Get the provider + provider := cmd.Flags().Lookup("provider").Value.String() + logrus.Debug("Checking validation of provider %s", provider) + + // OpenShift specific flags + deploymentConfig := cmd.Flags().Lookup("deployment-config").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 + + // Check validations against provider flags + switch { + case provider == "openshift": + if chart { + logrus.Fatalf("--chart, -c is a Kubernetes only flag") + } + if daemonSet { + logrus.Fatalf("--daemon-set is a Kubernetes only flag") + } + if replicationController { + logrus.Fatalf("--replication-controller is a Kubernetes only flag") + } + if deployment { + logrus.Fatalf("--deployment, -d is a Kubernetes only flag") + } + case provider == "kubernetes": + if deploymentConfig { + logrus.Fatalf("--deployment-config is an OpenShift only flag") + } + } + + // Standard checks regardless of provider if len(opt.OutFile) != 0 && opt.ToStdout { logrus.Fatalf("Error: --out and --stdout can't be set at the same time") } @@ -65,19 +103,17 @@ func validateFlags(c *cli.Context, opt *kobject.ConvertOptions) { logrus.Fatalf("Error: --replicas cannot be negative") } - dabFile := c.GlobalString("bundle") - - if len(dabFile) > 0 { + if len(bundle) > 0 { inputFormat = "bundle" - opt.InputFile = dabFile + opt.InputFile = bundle } - if len(dabFile) > 0 && c.GlobalIsSet("file") { + if len(bundle) > 0 && isFileSet { logrus.Fatalf("Error: 'compose' file and 'dab' file cannot be specified at the same time") } - if len(c.Args()) != 0 { - logrus.Fatal("Unknown Argument(s): ", strings.Join(c.Args(), ",")) + if len(args) != 0 { + logrus.Fatal("Unknown Argument(s): ", strings.Join(args, ",")) } } @@ -127,23 +163,8 @@ func validateControllers(opt *kobject.ConvertOptions) { } // Convert transforms docker compose or dab file to k8s objects -func Convert(c *cli.Context) { - opt := kobject.ConvertOptions{ - ToStdout: c.BoolT("stdout"), - CreateChart: c.BoolT("chart"), - GenerateYaml: c.BoolT("yaml"), - Replicas: c.Int("replicas"), - InputFile: c.GlobalString("file"), - OutFile: c.String("out"), - Provider: strings.ToLower(c.GlobalString("provider")), - CreateD: c.BoolT("deployment"), - CreateDS: c.BoolT("daemonset"), - CreateRC: c.BoolT("replicationcontroller"), - CreateDeploymentConfig: c.BoolT("deploymentconfig"), - EmptyVols: c.BoolT("emptyvols"), - } +func Convert(opt kobject.ConvertOptions) { - validateFlags(c, &opt) validateControllers(&opt) // loader parses input from file into komposeObject. @@ -168,14 +189,8 @@ func Convert(c *cli.Context) { } // Up brings up deployment, svc. -func Up(c *cli.Context) { - opt := kobject.ConvertOptions{ - InputFile: c.GlobalString("file"), - Replicas: 1, - Provider: strings.ToLower(c.GlobalString("provider")), - EmptyVols: c.BoolT("emptyvols"), - } - validateFlags(c, &opt) +func Up(opt kobject.ConvertOptions) { + validateControllers(&opt) // loader parses input from file into komposeObject. @@ -200,14 +215,8 @@ func Up(c *cli.Context) { } // Down deletes all deployment, svc. -func Down(c *cli.Context) { - opt := kobject.ConvertOptions{ - InputFile: c.GlobalString("file"), - Replicas: 1, - Provider: strings.ToLower(c.GlobalString("provider")), - EmptyVols: c.BoolT("emptyvols"), - } - validateFlags(c, &opt) +func Down(opt kobject.ConvertOptions) { + validateControllers(&opt) // loader parses input from file into komposeObject. diff --git a/cli/app/app_test.go b/pkg/transformer/utils_test.go similarity index 94% rename from cli/app/app_test.go rename to pkg/transformer/utils_test.go index 2308f6fb..78422fad 100644 --- a/cli/app/app_test.go +++ b/pkg/transformer/utils_test.go @@ -14,13 +14,11 @@ See the License for the specific language governing permissions and limitations under the License. */ -package app +package transformer import ( "fmt" "testing" - - "github.com/kubernetes-incubator/kompose/pkg/transformer" ) func TestParseVolume(t *testing.T) { @@ -101,7 +99,7 @@ func TestParseVolume(t *testing.T) { } for _, test := range tests { - name, host, container, mode, err := transformer.ParseVolume(test.volume) + name, host, container, mode, err := ParseVolume(test.volume) if err != nil { t.Errorf("In test case %q, returned unexpected error %v", test.test, err) }