deep-stack/kompose
4
0
Fork 0
forked from LaconicNetwork/kompose
Code Pull Requests Activity

Switch to spf13/cobra from urfave/cli

Browse Source 
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
This commit is contained in:
Charlie Drage
2016-12-22 08:15:51 -05:00
parent 240f150492
commit 1b9228e696
9 changed files with 413 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cmd/convert.go
+129
View File
@@ -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
+59
View File
@@ -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
+92
View File
@@ -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
+59
View File
@@ -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
+40
View File
@@ -0,0 +1,40 @@
/*
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"
"github.com/spf13/cobra"
)
var (
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)
}