Switch to spf13/cobra from urfave/cli

There's A LOT happening in this commit, so here's an outline:

First off, urfave/cli has been removed in favour of spf13/cobra. With
this, comes changes to the formatting as well as the help page for
Kompose.

Upon converting, I noticed a CLI flag was NOT appearing for OpenShift.
Specifically, --deploymentconfig. This has been added with a note
that says it is OpenShift only.

Exit codes have been fixed. If the conversion / down / up fails for
any reason, Kompose will exit with Code 1.

--verbose as well as --suppress-warnings can now be set at the
same time.

app_test.go in the cli directory has been moved to pkg/transformer
to better reflect the testing coverage.

version.go has been removed and converted to it's own CLI command in
conjuction with (most) Go software. A new CLI command has been
created. kompose version

--dab isn't a conventional way for short-form CLI paramters. This
has been shortened to -b for bundle.

CLI flags consisting of only two/three letters have been removed due to
it being unconventional for CLI. For example, --dc was removed in preference
for --deploymentconfig

--replicas has been added as an option when using kompose down or
kompose up. This has been added as previously in app.go the
replica amount was hard-coded as 1.

Differentiating names have been used for flags. For example,
persistent flags use the name Global (ex. GlobalOut). Command-specific
flags have their own names (ex. UpOpt).

Closes #239 #253

cli/command/command.go

@@ -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",
-		},
-	}
-}

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)
+}

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)
+}

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.")
+}

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)
+}

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"
-	VERSION = "0.1.2"
-
-	// GITCOMMIT will be overwritten automatically by the build system
 	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)
+}

main.go

@@ -16,37 +16,8 @@ limitations under the License.
 
 package main
 
-import (
+import "github.com/kubernetes-incubator/kompose/cmd"
-	"os"
-
-	"github.com/kubernetes-incubator/kompose/cli/command"
-	"github.com/kubernetes-incubator/kompose/version"
-	"github.com/urfave/cli"
-)
 
 func main() {
-	app := cli.NewApp()
+	cmd.Execute()
-	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)
 }

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(bundle) > 0 {
-
-	if len(dabFile) > 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 {
+	if len(args) != 0 {
-		logrus.Fatal("Unknown Argument(s): ", strings.Join(c.Args(), ","))
+		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) {
+func Convert(opt kobject.ConvertOptions) {
-	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"),
-	}
 
-	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) {
+func Up(opt kobject.ConvertOptions) {
-	opt := kobject.ConvertOptions{
+
-		InputFile: c.GlobalString("file"),
-		Replicas:  1,
-		Provider:  strings.ToLower(c.GlobalString("provider")),
-		EmptyVols: c.BoolT("emptyvols"),
-	}
-	validateFlags(c, &opt)
 	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) {
+func Down(opt kobject.ConvertOptions) {
-	opt := kobject.ConvertOptions{
+
-		InputFile: c.GlobalString("file"),
-		Replicas:  1,
-		Provider:  strings.ToLower(c.GlobalString("provider")),
-		EmptyVols: c.BoolT("emptyvols"),
-	}
-	validateFlags(c, &opt)
 	validateControllers(&opt)
 
 	// loader parses input from file into komposeObject.

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)
 		}