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
cli/app/app.go
-264
View File
@@ -1,264 +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 app
import (
"fmt"
"strings"
"github.com/Sirupsen/logrus"
"github.com/urfave/cli"
// install kubernetes api
_ "k8s.io/kubernetes/pkg/api/install"
_ "k8s.io/kubernetes/pkg/apis/extensions/install"
// install OpenShift api
_ "github.com/openshift/origin/pkg/deploy/api/install"
_ "github.com/openshift/origin/pkg/image/api/install"
_ "github.com/openshift/origin/pkg/route/api/install"
"github.com/kubernetes-incubator/kompose/pkg/kobject"
"github.com/kubernetes-incubator/kompose/pkg/loader"
"github.com/kubernetes-incubator/kompose/pkg/transformer"
"github.com/kubernetes-incubator/kompose/pkg/transformer/kubernetes"
"github.com/kubernetes-incubator/kompose/pkg/transformer/openshift"
)
const (
DefaultComposeFile = "docker-compose.yml"
DefaultProvider = "kubernetes"
)
var inputFormat = "compose"
func validateFlags(c *cli.Context, opt *kobject.ConvertOptions) {
if opt.OutFile == "-" {
opt.ToStdout = true
opt.OutFile = ""
}
if len(opt.OutFile) != 0 && opt.ToStdout {
logrus.Fatalf("Error: --out and --stdout can't be set at the same time")
}
if opt.CreateChart && opt.ToStdout {
logrus.Fatalf("Error: chart cannot be generated when --stdout is specified")
}
if opt.Replicas < 0 {
logrus.Fatalf("Error: --replicas cannot be negative")
}
dabFile := c.GlobalString("bundle")
if len(dabFile) > 0 {
inputFormat = "bundle"
opt.InputFile = dabFile
}
if len(dabFile) > 0 && c.GlobalIsSet("file") {
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(), ","))
}
}
func validateControllers(opt *kobject.ConvertOptions) {
singleOutput := len(opt.OutFile) != 0 || opt.OutFile == "-" || opt.ToStdout
if opt.Provider == "kubernetes" {
// create deployment by default if no controller has been set
if !opt.CreateD && !opt.CreateDS && !opt.CreateRC {
opt.CreateD = true
}
if singleOutput {
count := 0
if opt.CreateD {
count++
}
if opt.CreateDS {
count++
}
if opt.CreateRC {
count++
}
if count > 1 {
logrus.Fatalf("Error: only one kind of Kubernetes resource can be generated when --out or --stdout is specified")
}
}
} else if opt.Provider == "openshift" {
// create deploymentconfig by default if no controller has been set
if !opt.CreateDeploymentConfig {
opt.CreateDeploymentConfig = true
}
if singleOutput {
count := 0
if opt.CreateDeploymentConfig {
count++
}
// Add more controllers here once they are available in OpenShift
// if opt.foo {count++}
if count > 1 {
logrus.Fatalf("Error: only one kind of OpenShift resource can be generated when --out or --stdout is specified")
}
}
}
}
// 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"),
}
validateFlags(c, &opt)
validateControllers(&opt)
// loader parses input from file into komposeObject.
l, err := loader.GetLoader(inputFormat)
if err != nil {
logrus.Fatal(err)
}
komposeObject := kobject.KomposeObject{
ServiceConfigs: make(map[string]kobject.ServiceConfig),
}
komposeObject = l.LoadFile(opt.InputFile)
// Get a transformer that maps komposeObject to provider's primitives
t := getTransformer(opt)
// Do the transformation
objects := t.Transform(komposeObject, opt)
// Print output
kubernetes.PrintList(objects, opt)
}
// 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)
validateControllers(&opt)
// loader parses input from file into komposeObject.
l, err := loader.GetLoader(inputFormat)
if err != nil {
logrus.Fatal(err)
}
komposeObject := kobject.KomposeObject{
ServiceConfigs: make(map[string]kobject.ServiceConfig),
}
komposeObject = l.LoadFile(opt.InputFile)
// Get the transformer
t := getTransformer(opt)
//Submit objects to provider
errDeploy := t.Deploy(komposeObject, opt)
if errDeploy != nil {
logrus.Fatalf("Error while deploying application: %s", errDeploy)
}
}
// 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)
validateControllers(&opt)
// loader parses input from file into komposeObject.
l, err := loader.GetLoader(inputFormat)
if err != nil {
logrus.Fatal(err)
}
komposeObject := kobject.KomposeObject{
ServiceConfigs: make(map[string]kobject.ServiceConfig),
}
komposeObject = l.LoadFile(opt.InputFile)
// Get the transformer
t := getTransformer(opt)
//Remove deployed application
errUndeploy := t.Undeploy(komposeObject, opt)
if errUndeploy != nil {
logrus.Fatalf("Error while deleting application: %s", errUndeploy)
}
}
// Convenience method to return the appropriate Transformer based on
// what provider we are using.
func getTransformer(opt kobject.ConvertOptions) transformer.Transformer {
var t transformer.Transformer
if opt.Provider == "kubernetes" {
// Create/Init new Kubernetes object with CLI opts
t = &kubernetes.Kubernetes{Opt: opt}
} else {
// Create/Init new OpenShift object that is initialized with a newly
// created Kubernetes object. Openshift inherits from Kubernetes
t = &openshift.OpenShift{Kubernetes: kubernetes.Kubernetes{Opt: opt}}
}
return t
}
func askForConfirmation() bool {
var response string
_, err := fmt.Scanln(&response)
if err != nil {
logrus.Fatal(err)
}
if response == "yes" {
return true
} else if response == "no" {
return false
} else {
fmt.Println("Please type yes or no and then press enter:")
return askForConfirmation()
}
}
cli/app/app_test.go
-121
View File
@@ -1,121 +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 app
import (
"fmt"
"testing"
"github.com/kubernetes-incubator/kompose/pkg/transformer"
)
func TestParseVolume(t *testing.T) {
name1 := "datavolume"
host1 := "./cache"
host2 := "~/configs"
container1 := "/tmp/cache"
container2 := "/etc/configs/"
mode := "rw"
tests := []struct {
test, volume, name, host, container, mode string
}{
{
"name:host:container:mode",
fmt.Sprintf("%s:%s:%s:%s", name1, host1, container1, mode),
name1,
host1,
container1,
mode,
},
{
"host:container:mode",
fmt.Sprintf("%s:%s:%s", host2, container2, mode),
"",
host2,
container2,
mode,
},
{
"name:container:mode",
fmt.Sprintf("%s:%s:%s", name1, container1, mode),
name1,
"",
container1,
mode,
},
{
"name:host:container",
fmt.Sprintf("%s:%s:%s", name1, host1, container1),
name1,
host1,
container1,
"",
},
{
"host:container",
fmt.Sprintf("%s:%s", host1, container1),
"",
host1,
container1,
"",
},
{
"container:mode",
fmt.Sprintf("%s:%s", container2, mode),
"",
"",
container2,
mode,
},
{
"name:container",
fmt.Sprintf("%s:%s", name1, container1),
name1,
"",
container1,
"",
},
{
"container",
fmt.Sprintf("%s", container2),
"",
"",
container2,
"",
},
}
for _, test := range tests {
name, host, container, mode, err := transformer.ParseVolume(test.volume)
if err != nil {
t.Errorf("In test case %q, returned unexpected error %v", test.test, err)
}
if name != test.name {
t.Errorf("In test case %q, returned volume name %s, expected %s", test.test, name, test.name)
}
if host != test.host {
t.Errorf("In test case %q, returned host path %s, expected %s", test.test, host, test.host)
}
if container != test.container {
t.Errorf("In test case %q, returned container path %s, expected %s", test.test, container, test.container)
}
if mode != test.mode {
t.Errorf("In test case %q, returned access mode %s, expected %s", test.test, mode, test.mode)
}
}
}
cli/command/command.go
-260
View File
@@ -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",
},
}
}