From 93d4b88d842280b88c480df48b8013638ef59ecf Mon Sep 17 00:00:00 2001 From: Ta-Ching Chen Date: Tue, 5 Nov 2019 16:50:13 +0800 Subject: [PATCH] Make CLI functions return error instead of fatal out (#1379) Before this PR, CLI functions fatal out when encountering error instead of returning it. Such behavior makes it hard to reuse the functions nor writing unit tests. This PR aims to make functions return errors instead of error out. --- cmd/fission-cli/main.go | 7 +- pkg/fission-cli/cli.go | 82 ++++---- .../cliwrapper/driver/urfavecli/urfavecli.go | 9 +- pkg/fission-cli/cmd/canaryconfig/create.go | 11 +- pkg/fission-cli/cmd/canaryconfig/delete.go | 10 +- pkg/fission-cli/cmd/canaryconfig/get.go | 10 +- pkg/fission-cli/cmd/canaryconfig/list.go | 8 +- pkg/fission-cli/cmd/canaryconfig/update.go | 10 +- pkg/fission-cli/cmd/environment/create.go | 50 +++-- pkg/fission-cli/cmd/environment/delete.go | 16 +- pkg/fission-cli/cmd/environment/get.go | 16 +- pkg/fission-cli/cmd/environment/list.go | 16 +- pkg/fission-cli/cmd/environment/update.go | 46 ++-- pkg/fission-cli/cmd/function/create.go | 26 ++- pkg/fission-cli/cmd/function/delete.go | 10 +- pkg/fission-cli/cmd/function/get.go | 10 +- pkg/fission-cli/cmd/function/getmeta.go | 10 +- pkg/fission-cli/cmd/function/list.go | 8 +- pkg/fission-cli/cmd/function/log.go | 16 +- pkg/fission-cli/cmd/function/test.go | 22 +- pkg/fission-cli/cmd/function/update.go | 20 +- pkg/fission-cli/cmd/httptrigger/create.go | 13 +- pkg/fission-cli/cmd/httptrigger/delete.go | 13 +- pkg/fission-cli/cmd/httptrigger/get.go | 8 +- pkg/fission-cli/cmd/httptrigger/list.go | 8 +- pkg/fission-cli/cmd/httptrigger/update.go | 13 +- pkg/fission-cli/cmd/kubewatch/create.go | 11 +- pkg/fission-cli/cmd/kubewatch/delete.go | 8 +- pkg/fission-cli/cmd/kubewatch/list.go | 8 +- pkg/fission-cli/cmd/mqtrigger/create.go | 21 +- pkg/fission-cli/cmd/mqtrigger/delete.go | 10 +- pkg/fission-cli/cmd/mqtrigger/list.go | 8 +- pkg/fission-cli/cmd/mqtrigger/update.go | 10 +- pkg/fission-cli/cmd/package/create.go | 28 ++- pkg/fission-cli/cmd/package/delete.go | 8 +- pkg/fission-cli/cmd/package/get.go | 19 +- pkg/fission-cli/cmd/package/info.go | 13 +- pkg/fission-cli/cmd/package/list.go | 8 +- pkg/fission-cli/cmd/package/package.go | 35 ++-- pkg/fission-cli/cmd/package/rebuild.go | 8 +- pkg/fission-cli/cmd/package/update.go | 8 +- pkg/fission-cli/cmd/package/util/util.go | 58 +++-- pkg/fission-cli/cmd/plugin/list.go | 8 +- pkg/fission-cli/cmd/recorder/create.go | 8 +- pkg/fission-cli/cmd/recorder/delete.go | 10 +- pkg/fission-cli/cmd/recorder/get.go | 8 +- pkg/fission-cli/cmd/recorder/list.go | 8 +- pkg/fission-cli/cmd/recorder/update.go | 8 +- pkg/fission-cli/cmd/records/view.go | 47 ++--- pkg/fission-cli/cmd/replay/replay.go | 8 +- pkg/fission-cli/cmd/spec/apply.go | 61 ++++-- pkg/fission-cli/cmd/spec/buildwatch.go | 7 +- pkg/fission-cli/cmd/spec/destroy.go | 19 +- pkg/fission-cli/cmd/spec/init.go | 24 ++- pkg/fission-cli/cmd/spec/spec.go | 27 +-- pkg/fission-cli/cmd/spec/validate.go | 24 ++- pkg/fission-cli/cmd/support/dump.go | 12 +- pkg/fission-cli/cmd/support/resources/crd.go | 18 +- .../cmd/support/resources/kubernetes.go | 26 +-- .../cmd/support/resources/resource.go | 6 +- pkg/fission-cli/cmd/timetrigger/create.go | 8 +- pkg/fission-cli/cmd/timetrigger/delete.go | 10 +- pkg/fission-cli/cmd/timetrigger/list.go | 8 +- pkg/fission-cli/cmd/timetrigger/test.go | 8 +- pkg/fission-cli/cmd/timetrigger/update.go | 10 +- pkg/fission-cli/cmd/util.go | 143 ------------- pkg/fission-cli/cmd/version/version.go | 11 +- pkg/fission-cli/{log => consolemsg}/log.go | 6 +- pkg/fission-cli/{cmd/doc.go => flag/const.go} | 2 +- pkg/fission-cli/logdb/influxdb.go | 7 +- pkg/fission-cli/util/portforward.go | 57 ++--- pkg/fission-cli/util/util.go | 198 ++++++++++++++---- 72 files changed, 894 insertions(+), 632 deletions(-) delete mode 100644 pkg/fission-cli/cmd/util.go rename pkg/fission-cli/{log => consolemsg}/log.go (91%) rename pkg/fission-cli/{cmd/doc.go => flag/const.go} (99%) diff --git a/cmd/fission-cli/main.go b/cmd/fission-cli/main.go index cc021f01..3ea048b0 100644 --- a/cmd/fission-cli/main.go +++ b/cmd/fission-cli/main.go @@ -17,11 +17,16 @@ limitations under the License. package main import ( + "fmt" "os" fcli "github.com/fission/fission/pkg/fission-cli" ) func main() { - fcli.NewCliApp().Run(os.Args) + err := fcli.NewCliApp().Run(os.Args) + if err != nil { + fmt.Printf("Error: %v\n", err.Error()) + os.Exit(1) + } } diff --git a/pkg/fission-cli/cli.go b/pkg/fission-cli/cli.go index 66d9a8bf..9f09d330 100644 --- a/pkg/fission-cli/cli.go +++ b/pkg/fission-cli/cli.go @@ -20,7 +20,6 @@ import ( "encoding/json" "fmt" "net/http" - "os" "strings" "time" @@ -29,7 +28,6 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "github.com/fission/fission/pkg/fission-cli/cliwrapper/driver/urfavecli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/canaryconfig" "github.com/fission/fission/pkg/fission-cli/cmd/environment" "github.com/fission/fission/pkg/fission-cli/cmd/function" @@ -45,24 +43,17 @@ import ( "github.com/fission/fission/pkg/fission-cli/cmd/support" "github.com/fission/fission/pkg/fission-cli/cmd/timetrigger" "github.com/fission/fission/pkg/fission-cli/cmd/version" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" + "github.com/fission/fission/pkg/fission-cli/flag" "github.com/fission/fission/pkg/info" "github.com/fission/fission/pkg/plugin" "github.com/fission/fission/pkg/types" ) func cliHook(c *cli.Context) error { - log.Verbosity = c.Int("verbosity") - log.Verbose(2, "Verbosity = 2") - - err := flagValueParser(c.Args()) - if err != nil { - // The cli package wont't print out error, as a workaround we need to - // fatal here instead of return it. - log.Fatal(err) - } - - return nil + consolemsg.Verbosity = c.Int("verbosity") + consolemsg.Verbose(2, "Verbosity = 2") + return flagValueParser(c.Args()) } func NewCliApp() *cli.App { @@ -81,9 +72,9 @@ func NewCliApp() *cli.App { } app.Flags = []cli.Flag{ - cli.StringFlag{Name: cmd.FISSION_SERVER, Value: "", Usage: "Fission server URL"}, - cli.IntFlag{Name: cmd.GLOBAL_VERBOSITY, Value: 1, Usage: "CLI verbosity (0 is quiet, 1 is the default, 2 is verbose.)"}, - cli.BoolFlag{Name: cmd.GLOBAL_PLUGIN, Hidden: true}, + cli.StringFlag{Name: flag.FISSION_SERVER, Value: "", Usage: "Fission server URL"}, + cli.IntFlag{Name: flag.GLOBAL_VERBOSITY, Value: 1, Usage: "CLI verbosity (0 is quiet, 1 is the default, 2 is verbose.)"}, + cli.BoolFlag{Name: flag.GLOBAL_PLUGIN, Hidden: true}, } // all resource create commands accept --spec @@ -91,7 +82,7 @@ func NewCliApp() *cli.App { // namespace reference for all objects fnNamespaceFlag := cli.StringFlag{Name: "fnNamespace, fns", Value: metav1.NamespaceDefault, Usage: "Namespace for function object"} - envNamespaceFlag := cli.StringFlag{Name: cmd.GetCliFlagName(cmd.ENVIRONMENT_NAMESPACE, cmd.ENVIRONMENT_NAMESPACE_ALIAS), Value: metav1.NamespaceDefault, Usage: "Namespace for environment object"} + envNamespaceFlag := cli.StringFlag{Name: flag.GetCliFlagName(flag.ENVIRONMENT_NAMESPACE, flag.ENVIRONMENT_NAMESPACE_ALIAS), Value: metav1.NamespaceDefault, Usage: "Namespace for environment object"} pkgNamespaceFlag := cli.StringFlag{Name: "pkgNamespace, pkgns", Value: metav1.NamespaceDefault, Usage: "Namespace for package object"} triggerNamespaceFlag := cli.StringFlag{Name: "triggerNamespace, triggerns", Value: metav1.NamespaceDefault, Usage: "Namespace for trigger object"} recorderNamespaceFlag := cli.StringFlag{Name: "recorderNamespace, recorderns", Value: metav1.NamespaceDefault, Usage: "Namespace for recorder object"} @@ -102,13 +93,13 @@ func NewCliApp() *cli.App { htUrlFlag := cli.StringFlag{Name: "url", Usage: "URL pattern (See gorilla/mux supported patterns)"} // Resource & scale related flags (Used in env and function) - minCpu := cli.IntFlag{Name: cmd.RUNTIME_MINCPU, Usage: "Minimum CPU to be assigned to pod (In millicore, minimum 1)"} - maxCpu := cli.IntFlag{Name: cmd.RUNTIME_MAXCPU, Usage: "Maximum CPU to be assigned to pod (In millicore, minimum 1)"} - minMem := cli.IntFlag{Name: cmd.RUNTIME_MINMEMORY, Usage: "Minimum memory to be assigned to pod (In megabyte)"} - maxMem := cli.IntFlag{Name: cmd.RUNTIME_MAXMEMORY, Usage: "Maximum memory to be assigned to pod (In megabyte)"} - minScale := cli.IntFlag{Name: cmd.RUNTIME_MINSCALE, Usage: "Minimum number of pods (Uses resource inputs to configure HPA)"} - maxScale := cli.IntFlag{Name: cmd.RUNTIME_MAXSCALE, Usage: "Maximum number of pods (Uses resource inputs to configure HPA)"} - targetcpu := cli.IntFlag{Name: cmd.RUNTIME_TARGETCPU, Usage: "Target average CPU usage percentage across pods for scaling"} + minCpu := cli.IntFlag{Name: flag.RUNTIME_MINCPU, Usage: "Minimum CPU to be assigned to pod (In millicore, minimum 1)"} + maxCpu := cli.IntFlag{Name: flag.RUNTIME_MAXCPU, Usage: "Maximum CPU to be assigned to pod (In millicore, minimum 1)"} + minMem := cli.IntFlag{Name: flag.RUNTIME_MINMEMORY, Usage: "Minimum memory to be assigned to pod (In megabyte)"} + maxMem := cli.IntFlag{Name: flag.RUNTIME_MAXMEMORY, Usage: "Maximum memory to be assigned to pod (In megabyte)"} + minScale := cli.IntFlag{Name: flag.RUNTIME_MINSCALE, Usage: "Minimum number of pods (Uses resource inputs to configure HPA)"} + maxScale := cli.IntFlag{Name: flag.RUNTIME_MAXSCALE, Usage: "Maximum number of pods (Uses resource inputs to configure HPA)"} + targetcpu := cli.IntFlag{Name: flag.RUNTIME_TARGETCPU, Usage: "Target average CPU usage percentage across pods for scaling"} specializationTimeoutFlag := cli.IntFlag{Name: "specializationtimeout, st", Value: 120, Usage: "Timeout for newdeploy to wait for function pod creation"} // functions @@ -230,15 +221,15 @@ func NewCliApp() *cli.App { reqIDFlag := cli.StringFlag{Name: "reqUID", Usage: "Replay a particular request by providing the reqUID (to view reqUIDs, do 'fission records view')"} // environments - envNameFlag := cli.StringFlag{Name: cmd.RESOURCE_NAME, Usage: "Environment name"} - envPoolsizeFlag := cli.IntFlag{Name: cmd.ENVIRONMENT_POOLSIZE, Value: 3, Usage: "Size of the pool"} - envImageFlag := cli.StringFlag{Name: cmd.ENVIRONMENT_IMAGE, Usage: "Environment image URL"} - envBuilderImageFlag := cli.StringFlag{Name: cmd.ENVIRONMENT_BUILDER, Usage: "Environment builder image URL (optional)"} - envBuildCmdFlag := cli.StringFlag{Name: cmd.ENVIRONMENT_BUILDCOMMAND, Usage: "Build command for environment builder to build source package (optional)"} - envKeepArchiveFlag := cli.BoolFlag{Name: cmd.ENVIRONMENT_KEEPARCHIVE, Usage: "Keep the archive instead of extracting it into a directory (optional, defaults to false)"} - envExternalNetworkFlag := cli.BoolFlag{Name: cmd.ENVIRONMENT_EXTERNAL_NETWORK, Usage: "Allow environment access external network when istio feature enabled (optional, defaults to false)"} - envTerminationGracePeriodFlag := cli.Int64Flag{Name: cmd.GetCliFlagName(cmd.ENVIRONMENT_GRACE_PERIOD, cmd.ENVIRONMENT_GRACE_PERIOD_ALIAS), Value: 360, Usage: "The grace time (in seconds) for pod to perform connection draining before termination (optional)"} - envVersionFlag := cli.IntFlag{Name: cmd.ENVIRONMENT_VERSION, Value: 1, Usage: "Environment API version (1 means v1 interface)"} + envNameFlag := cli.StringFlag{Name: flag.RESOURCE_NAME, Usage: "Environment name"} + envPoolsizeFlag := cli.IntFlag{Name: flag.ENVIRONMENT_POOLSIZE, Value: 3, Usage: "Size of the pool"} + envImageFlag := cli.StringFlag{Name: flag.ENVIRONMENT_IMAGE, Usage: "Environment image URL"} + envBuilderImageFlag := cli.StringFlag{Name: flag.ENVIRONMENT_BUILDER, Usage: "Environment builder image URL (optional)"} + envBuildCmdFlag := cli.StringFlag{Name: flag.ENVIRONMENT_BUILDCOMMAND, Usage: "Build command for environment builder to build source package (optional)"} + envKeepArchiveFlag := cli.BoolFlag{Name: flag.ENVIRONMENT_KEEPARCHIVE, Usage: "Keep the archive instead of extracting it into a directory (optional, defaults to false)"} + envExternalNetworkFlag := cli.BoolFlag{Name: flag.ENVIRONMENT_EXTERNAL_NETWORK, Usage: "Allow environment access external network when istio feature enabled (optional, defaults to false)"} + envTerminationGracePeriodFlag := cli.Int64Flag{Name: flag.GetCliFlagName(flag.ENVIRONMENT_GRACE_PERIOD, flag.ENVIRONMENT_GRACE_PERIOD_ALIAS), Value: 360, Usage: "The grace time (in seconds) for pod to perform connection draining before termination (optional)"} + envVersionFlag := cli.IntFlag{Name: flag.ENVIRONMENT_VERSION, Value: 1, Usage: "Environment API version (1 means v1 interface)"} envSubcommands := []cli.Command{ {Name: "create", Aliases: []string{"add"}, Usage: "Add an environment", Flags: []cli.Flag{envNameFlag, envNamespaceFlag, envPoolsizeFlag, envImageFlag, envBuilderImageFlag, envBuildCmdFlag, envKeepArchiveFlag, minCpu, maxCpu, minMem, maxMem, envVersionFlag, envExternalNetworkFlag, envTerminationGracePeriodFlag, specSaveFlag}, Action: urfavecli.Wrapper(environment.Create)}, {Name: "get", Usage: "Get environment details", Flags: []cli.Flag{envNameFlag, envNamespaceFlag}, Action: urfavecli.Wrapper(environment.Get)}, @@ -353,39 +344,37 @@ func handleNoCommand(ctx *cli.Context) error { Usage: ctx.App.Usage, }) if err != nil { - log.Fatal(fmt.Sprintf("Failed to marshal plugin metadata to JSON: %v", err)) + return errors.Errorf("Failed to marshal plugin metadata to JSON: %v", err) } fmt.Println(string(bs)) return nil } if len(ctx.Args()) > 0 { - handleCommandNotFound(ctx, ctx.Args().First()) - return nil + return handleCommandNotFound(ctx, ctx.Args().First()) } return cli.ShowAppHelp(ctx) } -func handleCommandNotFound(ctx *cli.Context, subCommand string) { +func handleCommandNotFound(ctx *cli.Context, subCommand string) error { pmd, err := plugin.Find(subCommand) if err != nil { switch err { case plugin.ErrPluginNotFound: url, ok := plugin.SearchRegistries(subCommand) if !ok { - log.Fatal("No help topic for '" + subCommand + "'") + return errors.New("No help topic for '" + subCommand + "'") } - log.Fatal(fmt.Sprintf(`Command '%v' is not installed. + return errors.Errorf(`Command '%v' is not installed. It is available to download at '%v'. To install it for your local Fission CLI: 1. Download the plugin binary for your OS from the URL 2. Ensure that the plugin binary is executable: chmod +x -2. Add the plugin binary to your $PATH: mv /usr/local/bin/fission-%v`, subCommand, url, subCommand)) +2. Add the plugin binary to your $PATH: mv /usr/local/bin/fission-%v`, subCommand, url, subCommand) default: - log.Fatal("Error occurred when invoking " + subCommand + ": " + err.Error()) + return errors.Wrap(err, "Error occurred when invoking "+subCommand) } - os.Exit(1) } // Rebuild global arguments string (urfave/cli does not have an option to get the raw input of the global flags) @@ -403,8 +392,10 @@ To install it for your local Fission CLI: err = plugin.Exec(pmd, args) if err != nil { - os.Exit(1) + return err } + + return nil } func flagValueParser(args []string) error { @@ -442,8 +433,7 @@ func flagValueParser(args []string) error { } if len(errorFlags) > 0 { - e := fmt.Sprintf("Unable to parse flags: %v\nThe argument should have only one input value. Please quote the input value if it contains wildcard characters(*).", strings.Join(errorFlags[:], ", ")) - return errors.New(e) + return errors.Errorf("Unable to parse flags: %v\nThe argument should have only one input value. Please quote the input value if it contains wildcard characters(*).", strings.Join(errorFlags[:], ", ")) } return nil diff --git a/pkg/fission-cli/cliwrapper/driver/urfavecli/urfavecli.go b/pkg/fission-cli/cliwrapper/driver/urfavecli/urfavecli.go index b673cbf1..759378f9 100644 --- a/pkg/fission-cli/cliwrapper/driver/urfavecli/urfavecli.go +++ b/pkg/fission-cli/cliwrapper/driver/urfavecli/urfavecli.go @@ -17,7 +17,6 @@ limitations under the License. package urfavecli import ( - "log" "time" "github.com/urfave/cli" @@ -39,13 +38,7 @@ func Parse(c *cli.Context) fCli.Input { func Wrapper(action cmd.CommandAction) func(*cli.Context) error { return func(c *cli.Context) error { - e := action(Cli{c: c}) - // Urfave cli doesn't exit with error code even error is not nil. - // We have to check whether error is empty and print error log here. - if e != nil { - log.Fatalf("%v", e) - } - return e + return action(Cli{c: c}) } } diff --git a/pkg/fission-cli/cmd/canaryconfig/create.go b/pkg/fission-cli/cmd/canaryconfig/create.go index 393468ec..a2fbbd1e 100644 --- a/pkg/fission-cli/cmd/canaryconfig/create.go +++ b/pkg/fission-cli/cmd/canaryconfig/create.go @@ -25,7 +25,6 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/util" "github.com/fission/fission/pkg/types" ) @@ -36,8 +35,12 @@ type CreateSubCommand struct { } func Create(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := CreateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -68,7 +71,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { } // check that the trigger exists in the same namespace. - m, err := cmd.GetMetadata("httptrigger", "fnNamespace", flags) + m, err := util.GetMetadata("httptrigger", "fnNamespace", flags) if err != nil { return errors.Wrap(err, "error finding http trigger in given namespace") } @@ -101,7 +104,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { return errors.Wrap(err, "error checking functions existence") } - canaryMetadata, err := cmd.GetMetadata("name", "fnNamespace", flags) + canaryMetadata, err := util.GetMetadata("name", "fnNamespace", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/canaryconfig/delete.go b/pkg/fission-cli/cmd/canaryconfig/delete.go index 0eb9936e..81702042 100644 --- a/pkg/fission-cli/cmd/canaryconfig/delete.go +++ b/pkg/fission-cli/cmd/canaryconfig/delete.go @@ -23,7 +23,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type DeleteSubCommand struct { @@ -31,14 +31,18 @@ type DeleteSubCommand struct { } func Delete(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := DeleteSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.run(flags) } func (opts *DeleteSubCommand) run(flags cli.Input) error { - metadata, err := cmd.GetMetadata("name", "canaryNamespace", flags) + metadata, err := util.GetMetadata("name", "canaryNamespace", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/canaryconfig/get.go b/pkg/fission-cli/cmd/canaryconfig/get.go index f1c34c3b..76e07722 100644 --- a/pkg/fission-cli/cmd/canaryconfig/get.go +++ b/pkg/fission-cli/cmd/canaryconfig/get.go @@ -25,7 +25,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type GetSubCommand struct { @@ -33,14 +33,18 @@ type GetSubCommand struct { } func Get(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := GetSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.run(flags) } func (opts *GetSubCommand) run(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "canaryNamespace", flags) + m, err := util.GetMetadata("name", "canaryNamespace", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/canaryconfig/list.go b/pkg/fission-cli/cmd/canaryconfig/list.go index f30caa52..f63935ce 100644 --- a/pkg/fission-cli/cmd/canaryconfig/list.go +++ b/pkg/fission-cli/cmd/canaryconfig/list.go @@ -25,7 +25,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type ListSubCommand struct { @@ -34,8 +34,12 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ListSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/canaryconfig/update.go b/pkg/fission-cli/cmd/canaryconfig/update.go index 76101c5e..eefb3d9a 100644 --- a/pkg/fission-cli/cmd/canaryconfig/update.go +++ b/pkg/fission-cli/cmd/canaryconfig/update.go @@ -25,7 +25,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type UpdateSubCommand struct { @@ -34,8 +34,12 @@ type UpdateSubCommand struct { } func Update(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := UpdateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -50,7 +54,7 @@ func (opts *UpdateSubCommand) do(flags cli.Input) error { func (opts *UpdateSubCommand) complete(flags cli.Input) error { // get the current config - m, err := cmd.GetMetadata("name", "canaryNamespace", flags) + m, err := util.GetMetadata("name", "canaryNamespace", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/environment/create.go b/pkg/fission-cli/cmd/environment/create.go index c5914343..1510cbee 100644 --- a/pkg/fission-cli/cmd/environment/create.go +++ b/pkg/fission-cli/cmd/environment/create.go @@ -26,9 +26,9 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/spec" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" + "github.com/fission/fission/pkg/fission-cli/flag" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -38,8 +38,12 @@ type CreateSubCommand struct { } func Create(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := CreateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -65,7 +69,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { // run write the resource to a spec file or create a fission CRD with remote fission server. // It also prints warning/error if necessary. func (opts *CreateSubCommand) run(flags cli.Input) error { - m, err := cmd.GetMetadata(cmd.RESOURCE_NAME, cmd.ENVIRONMENT_NAMESPACE, flags) + m, err := util.GetMetadata(flag.RESOURCE_NAME, flag.ENVIRONMENT_NAMESPACE, flags) if err != nil { return err } @@ -73,22 +77,26 @@ func (opts *CreateSubCommand) run(flags cli.Input) error { if err != nil { return err } else if len(envList) > 0 { - log.Verbose(2, "%d environment(s) are present in the %s namespace. "+ + consolemsg.Verbose(2, "%d environment(s) are present in the %s namespace. "+ "These environments are not isolated from each other; use separate namespaces if you need isolation.", len(envList), m.Namespace) } // if we're writing a spec, don't call the API // save to spec file - if flags.Bool(cmd.SPEC_SPEC) { + if flags.Bool(flag.SPEC_SPEC) { specFile := fmt.Sprintf("env-%v.yaml", m.Name) err = spec.SpecSave(*opts.env, specFile) - util.CheckErr(err, "create environment spec") + if err != nil { + return errors.Wrap(err, "error creating environment spec") + } return nil } _, err = opts.client.EnvironmentCreate(opts.env) - util.CheckErr(err, "create environment") + if err != nil { + return errors.Wrap(err, "error creating environment") + } fmt.Printf("environment '%v' created\n", m.Name) return nil @@ -98,36 +106,36 @@ func (opts *CreateSubCommand) run(flags cli.Input) error { func createEnvironmentFromCmd(flags cli.Input) (*fv1.Environment, error) { e := &multierror.Error{} - envNamespace := flags.String(cmd.ENVIRONMENT_NAMESPACE) - envBuildCmd := flags.String(cmd.ENVIRONMENT_BUILDCOMMAND) - envExternalNetwork := flags.Bool(cmd.ENVIRONMENT_EXTERNAL_NETWORK) - keepArchive := flags.Bool(cmd.ENVIRONMENT_KEEPARCHIVE) + envNamespace := flags.String(flag.ENVIRONMENT_NAMESPACE) + envBuildCmd := flags.String(flag.ENVIRONMENT_BUILDCOMMAND) + envExternalNetwork := flags.Bool(flag.ENVIRONMENT_EXTERNAL_NETWORK) + keepArchive := flags.Bool(flag.ENVIRONMENT_KEEPARCHIVE) - envName := flags.String(cmd.RESOURCE_NAME) + envName := flags.String(flag.RESOURCE_NAME) if len(envName) == 0 { e = multierror.Append(e, errors.New("Need a name, use --name.")) } - envImg := flags.String(cmd.ENVIRONMENT_IMAGE) + envImg := flags.String(flag.ENVIRONMENT_IMAGE) if len(envImg) == 0 { e = multierror.Append(e, errors.New("Need an image, use --image.")) } - envGracePeriod := flags.Int64(cmd.ENVIRONMENT_GRACE_PERIOD) + envGracePeriod := flags.Int64(flag.ENVIRONMENT_GRACE_PERIOD) if envGracePeriod <= 0 { envGracePeriod = 360 } - envVersion := flags.Int(cmd.ENVIRONMENT_VERSION) + envVersion := flags.Int(flag.ENVIRONMENT_VERSION) // Environment API interface version is not specified and // builder image is empty, set default interface version if envVersion == 0 { envVersion = 1 } - envBuilderImg := flags.String(cmd.ENVIRONMENT_BUILDER) + envBuilderImg := flags.String(flag.ENVIRONMENT_BUILDER) if len(envBuilderImg) > 0 { - if !flags.IsSet(cmd.ENVIRONMENT_VERSION) { + if !flags.IsSet(flag.ENVIRONMENT_VERSION) { // TODO: remove set env version to 2 silently, we need to warn user to set it explicitly. envVersion = 2 } @@ -137,13 +145,13 @@ func createEnvironmentFromCmd(flags cli.Input) (*fv1.Environment, error) { } poolsize := 3 - if flags.IsSet(cmd.ENVIRONMENT_POOLSIZE) { - poolsize = flags.Int(cmd.ENVIRONMENT_POOLSIZE) + if flags.IsSet(flag.ENVIRONMENT_POOLSIZE) { + poolsize = flags.Int(flag.ENVIRONMENT_POOLSIZE) // TODO: remove silently version 3 assignment, we need to warn user to set it explicitly. envVersion = 3 } - resourceReq, err := cmd.GetResourceReqs(flags, nil) + resourceReq, err := util.GetResourceReqs(flags, nil) if err != nil { e = multierror.Append(e, err) } diff --git a/pkg/fission-cli/cmd/environment/delete.go b/pkg/fission-cli/cmd/environment/delete.go index 55e6e68a..aabda322 100644 --- a/pkg/fission-cli/cmd/environment/delete.go +++ b/pkg/fission-cli/cmd/environment/delete.go @@ -19,9 +19,11 @@ package environment import ( "fmt" + "github.com/pkg/errors" + "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/flag" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -30,20 +32,26 @@ type DeleteSubCommand struct { } func Delete(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := DeleteSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } func (opts *DeleteSubCommand) do(flags cli.Input) error { - m, err := cmd.GetMetadata(cmd.RESOURCE_NAME, cmd.ENVIRONMENT_NAMESPACE, flags) + m, err := util.GetMetadata(flag.RESOURCE_NAME, flag.ENVIRONMENT_NAMESPACE, flags) if err != nil { return err } err = opts.client.EnvironmentDelete(m) - util.CheckErr(err, "delete environment") + if err != nil { + return errors.Wrap(err, "error deleting environment") + } fmt.Printf("environment '%v' deleted\n", m.Name) return nil diff --git a/pkg/fission-cli/cmd/environment/get.go b/pkg/fission-cli/cmd/environment/get.go index 69189470..2cf7edf7 100644 --- a/pkg/fission-cli/cmd/environment/get.go +++ b/pkg/fission-cli/cmd/environment/get.go @@ -21,9 +21,11 @@ import ( "os" "text/tabwriter" + "github.com/pkg/errors" + "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/flag" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -32,20 +34,26 @@ type GetSubCommand struct { } func Get(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := GetSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } func (opts *GetSubCommand) do(flags cli.Input) error { - m, err := cmd.GetMetadata(cmd.RESOURCE_NAME, cmd.ENVIRONMENT_NAMESPACE, flags) + m, err := util.GetMetadata(flag.RESOURCE_NAME, flag.ENVIRONMENT_NAMESPACE, flags) if err != nil { return err } env, err := opts.client.EnvironmentGet(m) - util.CheckErr(err, "get environment") + if err != nil { + return errors.Wrap(err, "error getting environment") + } w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0) diff --git a/pkg/fission-cli/cmd/environment/list.go b/pkg/fission-cli/cmd/environment/list.go index a3081b19..e937ef3d 100644 --- a/pkg/fission-cli/cmd/environment/list.go +++ b/pkg/fission-cli/cmd/environment/list.go @@ -21,9 +21,11 @@ import ( "os" "text/tabwriter" + "github.com/pkg/errors" + "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/flag" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -32,17 +34,23 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ListSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } func (opts *ListSubCommand) do(flags cli.Input) error { - envNamespace := flags.String(cmd.ENVIRONMENT_NAMESPACE) + envNamespace := flags.String(flag.ENVIRONMENT_NAMESPACE) envs, err := opts.client.EnvironmentList(envNamespace) - util.CheckErr(err, "list environments") + if err != nil { + return errors.Wrap(err, "error listing environments") + } w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0) fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\t%v\t%v\t%v\t%v\t%v\n", "NAME", "IMAGE", "BUILDER_IMAGE", "POOLSIZE", "MINCPU", "MAXCPU", "MINMEMORY", "MAXMEMORY", "EXTNET", "GRACETIME") diff --git a/pkg/fission-cli/cmd/environment/update.go b/pkg/fission-cli/cmd/environment/update.go index 52724af0..2ba89bb7 100644 --- a/pkg/fission-cli/cmd/environment/update.go +++ b/pkg/fission-cli/cmd/environment/update.go @@ -17,15 +17,15 @@ limitations under the License. package environment import ( - "errors" "fmt" "github.com/hashicorp/go-multierror" + "github.com/pkg/errors" fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/flag" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -35,8 +35,12 @@ type UpdateSubCommand struct { } func Update(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := UpdateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -50,13 +54,15 @@ func (opts *UpdateSubCommand) do(flags cli.Input) error { } func (opts *UpdateSubCommand) complete(flags cli.Input) error { - m, err := cmd.GetMetadata(cmd.RESOURCE_NAME, cmd.ENVIRONMENT_NAMESPACE, flags) + m, err := util.GetMetadata(flag.RESOURCE_NAME, flag.ENVIRONMENT_NAMESPACE, flags) if err != nil { return err } env, err := opts.client.EnvironmentGet(m) - util.CheckErr(err, "find environment") + if err != nil { + return errors.Wrap(err, "error finding environment") + } env, err = updateExistingEnvironmentWithCmd(env, flags) if err != nil { @@ -69,7 +75,9 @@ func (opts *UpdateSubCommand) complete(flags cli.Input) error { func (opts *UpdateSubCommand) run(flags cli.Input) error { _, err := opts.client.EnvironmentUpdate(opts.env) - util.CheckErr(err, "update environment") + if err != nil { + return errors.Wrap(err, "error updating environment") + } fmt.Printf("environment '%v' updated\n", opts.env.Metadata.Name) return nil @@ -79,10 +87,10 @@ func (opts *UpdateSubCommand) run(flags cli.Input) error { func updateExistingEnvironmentWithCmd(env *fv1.Environment, flags cli.Input) (*fv1.Environment, error) { e := &multierror.Error{} - envImg := flags.String(cmd.ENVIRONMENT_IMAGE) - envBuilderImg := flags.String(cmd.ENVIRONMENT_BUILDER) - envBuildCmd := flags.String(cmd.ENVIRONMENT_BUILDCOMMAND) - envExternalNetwork := flags.Bool(cmd.ENVIRONMENT_EXTERNAL_NETWORK) + envImg := flags.String(flag.ENVIRONMENT_IMAGE) + envBuilderImg := flags.String(flag.ENVIRONMENT_BUILDER) + envBuildCmd := flags.String(flag.ENVIRONMENT_BUILDCOMMAND) + envExternalNetwork := flags.Bool(flag.ENVIRONMENT_EXTERNAL_NETWORK) if len(envImg) == 0 && len(envBuilderImg) == 0 && len(envBuildCmd) == 0 { e = multierror.Append(e, errors.New("need --image to specify env image, or use --builder to specify env builder, or use --buildcmd to specify new build command")) @@ -103,23 +111,23 @@ func updateExistingEnvironmentWithCmd(env *fv1.Environment, flags cli.Input) (*f env.Spec.Builder.Command = envBuildCmd } - if flags.IsSet(cmd.ENVIRONMENT_POOLSIZE) { - env.Spec.Poolsize = flags.Int(cmd.ENVIRONMENT_POOLSIZE) + if flags.IsSet(flag.ENVIRONMENT_POOLSIZE) { + env.Spec.Poolsize = flags.Int(flag.ENVIRONMENT_POOLSIZE) } - if flags.IsSet(cmd.ENVIRONMENT_GRACE_PERIOD) { - env.Spec.TerminationGracePeriod = flags.Int64(cmd.ENVIRONMENT_GRACE_PERIOD) + if flags.IsSet(flag.ENVIRONMENT_GRACE_PERIOD) { + env.Spec.TerminationGracePeriod = flags.Int64(flag.ENVIRONMENT_GRACE_PERIOD) } - if flags.IsSet(cmd.ENVIRONMENT_KEEPARCHIVE) { - env.Spec.KeepArchive = flags.Bool(cmd.ENVIRONMENT_KEEPARCHIVE) + if flags.IsSet(flag.ENVIRONMENT_KEEPARCHIVE) { + env.Spec.KeepArchive = flags.Bool(flag.ENVIRONMENT_KEEPARCHIVE) } env.Spec.AllowAccessToExternalNetwork = envExternalNetwork - if flags.IsSet(cmd.RUNTIME_MINCPU) || flags.IsSet(cmd.RUNTIME_MAXCPU) || - flags.IsSet(cmd.RUNTIME_MINMEMORY) || flags.IsSet(cmd.RUNTIME_MAXMEMORY) || - flags.IsSet(cmd.RUNTIME_MINSCALE) || flags.IsSet(cmd.RUNTIME_MAXSCALE) { + if flags.IsSet(flag.RUNTIME_MINCPU) || flags.IsSet(flag.RUNTIME_MAXCPU) || + flags.IsSet(flag.RUNTIME_MINMEMORY) || flags.IsSet(flag.RUNTIME_MAXMEMORY) || + flags.IsSet(flag.RUNTIME_MINSCALE) || flags.IsSet(flag.RUNTIME_MAXSCALE) { e = multierror.Append(e, errors.New("updating resource limits/requests for existing environments is currently unsupported; re-create the environment instead")) } diff --git a/pkg/fission-cli/cmd/function/create.go b/pkg/fission-cli/cmd/function/create.go index 6759f68a..023a22fb 100644 --- a/pkg/fission-cli/cmd/function/create.go +++ b/pkg/fission-cli/cmd/function/create.go @@ -30,11 +30,11 @@ import ( "github.com/fission/fission/pkg/controller/client" ferror "github.com/fission/fission/pkg/error" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/httptrigger" _package "github.com/fission/fission/pkg/fission-cli/cmd/package" "github.com/fission/fission/pkg/fission-cli/cmd/spec" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" + "github.com/fission/fission/pkg/fission-cli/util" "github.com/fission/fission/pkg/types" ) @@ -50,8 +50,12 @@ type CreateSubCommand struct { } func Create(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := CreateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -79,10 +83,10 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { toSpec = true opts.specFile = fmt.Sprintf("function-%v.yaml", fnName) } - specDir := cmd.GetSpecDir(flags) + specDir := util.GetSpecDir(flags) // check for unique function names within a namespace - metadata, err := cmd.GetMetadata("name", "fnNamespace", flags) + metadata, err := util.GetMetadata("name", "fnNamespace", flags) if err != nil { return err } @@ -110,7 +114,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { if err != nil { return err } - resourceReq, err := cmd.GetResourceReqs(flags, &apiv1.ResourceRequirements{}) + resourceReq, err := util.GetResourceReqs(flags, &apiv1.ResourceRequirements{}) if err != nil { return err } @@ -129,7 +133,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { pkgMetadata = &pkg.Metadata envName = pkg.Spec.Environment.Name if envName != flags.String("env") { - log.Warn("Function's environment is different than package's environment, package's environment will be used for creating function") + consolemsg.Warn("Function's environment is different than package's environment, package's environment will be used for creating function") } envNamespace = pkg.Spec.Environment.Namespace } else { @@ -147,7 +151,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { }) if err != nil { if e, ok := err.(ferror.Error); ok && e.Code == ferror.ErrorNotFound { - log.Warn(fmt.Sprintf("Environment \"%v\" does not exist. Please create the environment before executing the function. \nFor example: `fission env create --name %v --envns %v --image `\n", envName, envName, envNamespace)) + consolemsg.Warn(fmt.Sprintf("Environment \"%v\" does not exist. Please create the environment before executing the function. \nFor example: `fission env create --name %v --envns %v --image `\n", envName, envName, envNamespace)) } else { return errors.Wrap(err, "error retrieving environment information") } @@ -192,7 +196,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { }) if err != nil { if k8serrors.IsNotFound(err) { - log.Warn(fmt.Sprintf("Secret %s not found in Namespace: %s. Secret needs to be present in the same namespace as function", secretName, fnNamespace)) + consolemsg.Warn(fmt.Sprintf("Secret %s not found in Namespace: %s. Secret needs to be present in the same namespace as function", secretName, fnNamespace)) } else { return errors.Wrap(err, "error checking secret") } @@ -216,7 +220,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { }) if err != nil { if k8serrors.IsNotFound(err) { - log.Warn(fmt.Sprintf("ConfigMap %s not found in Namespace: %s. ConfigMap needs to be present in the same namespace as function", cfgMapName, fnNamespace)) + consolemsg.Warn(fmt.Sprintf("ConfigMap %s not found in Namespace: %s. ConfigMap needs to be present in the same namespace as function", cfgMapName, fnNamespace)) } else { return errors.Wrap(err, "error checking configmap") } @@ -353,7 +357,7 @@ func getInvokeStrategy(flags cli.Input, existingInvokeStrategy *fv1.InvokeStrate } if flags.IsSet("mincpu") || flags.IsSet("maxcpu") || flags.IsSet("minmemory") || flags.IsSet("maxmemory") { - log.Warn("To limit CPU/Memory for function with executor type \"poolmgr\", please specify resources limits when creating environment") + consolemsg.Warn("To limit CPU/Memory for function with executor type \"poolmgr\", please specify resources limits when creating environment") } strategy = &fv1.InvokeStrategy{ StrategyType: fv1.StrategyTypeExecution, diff --git a/pkg/fission-cli/cmd/function/delete.go b/pkg/fission-cli/cmd/function/delete.go index ed8bf722..824bc4d2 100644 --- a/pkg/fission-cli/cmd/function/delete.go +++ b/pkg/fission-cli/cmd/function/delete.go @@ -23,7 +23,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type DeleteSubCommand struct { @@ -31,14 +31,18 @@ type DeleteSubCommand struct { } func Delete(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := DeleteSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } func (opts *DeleteSubCommand) do(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "fnNamespace", flags) + m, err := util.GetMetadata("name", "fnNamespace", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/function/get.go b/pkg/fission-cli/cmd/function/get.go index bdaa53d4..83de4cd4 100644 --- a/pkg/fission-cli/cmd/function/get.go +++ b/pkg/fission-cli/cmd/function/get.go @@ -24,7 +24,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type GetSubCommand struct { @@ -32,14 +32,18 @@ type GetSubCommand struct { } func Get(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := GetSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } func (opts *GetSubCommand) do(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "fnNamespace", flags) + m, err := util.GetMetadata("name", "fnNamespace", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/function/getmeta.go b/pkg/fission-cli/cmd/function/getmeta.go index a3084aba..10ee27fb 100644 --- a/pkg/fission-cli/cmd/function/getmeta.go +++ b/pkg/fission-cli/cmd/function/getmeta.go @@ -25,7 +25,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type GetMetaSubCommand struct { @@ -33,14 +33,18 @@ type GetMetaSubCommand struct { } func GetMeta(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := GetMetaSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } func (opts *GetMetaSubCommand) do(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "fnNamespace", flags) + m, err := util.GetMetadata("name", "fnNamespace", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/function/list.go b/pkg/fission-cli/cmd/function/list.go index 7e8c2fb4..af08da23 100644 --- a/pkg/fission-cli/cmd/function/list.go +++ b/pkg/fission-cli/cmd/function/list.go @@ -26,7 +26,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type ListSubCommand struct { @@ -34,8 +34,12 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ListSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/function/log.go b/pkg/fission-cli/cmd/function/log.go index 2e7801b2..62d6ad4f 100644 --- a/pkg/fission-cli/cmd/function/log.go +++ b/pkg/fission-cli/cmd/function/log.go @@ -25,7 +25,6 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/logdb" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -35,14 +34,18 @@ type LogSubCommand struct { } func Log(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := LogSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } func (opts *LogSubCommand) do(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "fnNamespace", flags) + m, err := util.GetMetadata("name", "fnNamespace", flags) if err != nil { return err } @@ -66,8 +69,13 @@ func (opts *LogSubCommand) do(flags cli.Input) error { return errors.Wrap(err, "error getting function") } + server, err := util.GetApplicationUrl("application=fission-api") + if err != nil { + return err + } + // request the controller to establish a proxy server to the database. - logDB, err := logdb.GetLogDB(dbType, util.GetServerUrl()) + logDB, err := logdb.GetLogDB(dbType, server) if err != nil { return errors.New("failed to connect log database") } diff --git a/pkg/fission-cli/cmd/function/test.go b/pkg/fission-cli/cmd/function/test.go index 6e41fabd..f365f211 100644 --- a/pkg/fission-cli/cmd/function/test.go +++ b/pkg/fission-cli/cmd/function/test.go @@ -30,7 +30,6 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/httptrigger" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -40,14 +39,18 @@ type TestSubCommand struct { } func Test(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := TestSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } func (opts *TestSubCommand) do(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "fnNamespace", flags) + m, err := util.GetMetadata("name", "fnNamespace", flags) if err != nil { return err } @@ -55,8 +58,10 @@ func (opts *TestSubCommand) do(flags cli.Input) error { routerURL := os.Getenv("FISSION_ROUTER") if len(routerURL) == 0 { // Portforward to the fission router - localRouterPort := util.SetupPortForward(util.GetFissionNamespace(), - "application=fission-router") + localRouterPort, err := util.SetupPortForward(util.GetFissionNamespace(), "application=fission-router") + if err != nil { + return err + } routerURL = "127.0.0.1:" + localRouterPort } else { routerURL = strings.TrimPrefix(routerURL, "http://") @@ -158,7 +163,12 @@ func printPodLogs(flags cli.Input) error { return errors.New("need --name argument.") } - queryURL, err := url.Parse(util.GetServerUrl()) + u, err := util.GetApplicationUrl("application=fission-api") + if err != nil { + return err + } + + queryURL, err := url.Parse(u) if err != nil { return errors.Wrap(err, "error parsing the base URL") } diff --git a/pkg/fission-cli/cmd/function/update.go b/pkg/fission-cli/cmd/function/update.go index bfe927f4..5cb378e1 100644 --- a/pkg/fission-cli/cmd/function/update.go +++ b/pkg/fission-cli/cmd/function/update.go @@ -26,9 +26,9 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" _package "github.com/fission/fission/pkg/fission-cli/cmd/package" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" + "github.com/fission/fission/pkg/fission-cli/util" "github.com/fission/fission/pkg/types" ) @@ -38,8 +38,12 @@ type UpdateSubCommand struct { } func Update(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := UpdateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -67,7 +71,7 @@ func (opts *UpdateSubCommand) complete(flags cli.Input) error { } fnNamespace := flags.String("fnNamespace") - m, err := cmd.GetMetadata("name", "fnNamespace", flags) + m, err := util.GetMetadata("name", "fnNamespace", flags) if err != nil { return err } @@ -127,7 +131,7 @@ func (opts *UpdateSubCommand) complete(flags cli.Input) error { Name: secretName, }) if k8serrors.IsNotFound(err) { - log.Warn(fmt.Sprintf("secret %s not found in Namespace: %s. Secret needs to be present in the same namespace as function", secretName, fnNamespace)) + consolemsg.Warn(fmt.Sprintf("secret %s not found in Namespace: %s. Secret needs to be present in the same namespace as function", secretName, fnNamespace)) } } @@ -151,7 +155,7 @@ func (opts *UpdateSubCommand) complete(flags cli.Input) error { Name: cfgMapName, }) if k8serrors.IsNotFound(err) { - log.Warn(fmt.Sprintf("ConfigMap %s not found in Namespace: %s. ConfigMap needs to be present in the same namespace as the function", cfgMapName, fnNamespace)) + consolemsg.Warn(fmt.Sprintf("ConfigMap %s not found in Namespace: %s. ConfigMap needs to be present in the same namespace as the function", cfgMapName, fnNamespace)) } } @@ -207,7 +211,7 @@ func (opts *UpdateSubCommand) complete(flags cli.Input) error { } } - resReqs, err := cmd.GetResourceReqs(flags, &function.Spec.Resources) + resReqs, err := util.GetResourceReqs(flags, &function.Spec.Resources) if err != nil { return err } @@ -267,7 +271,7 @@ func (opts *UpdateSubCommand) complete(flags cli.Input) error { } if function.Spec.Environment.Name != pkg.Spec.Environment.Name { - log.Warn("Function's environment is different than package's environment, package's environment will be used for updating function") + consolemsg.Warn("Function's environment is different than package's environment, package's environment will be used for updating function") function.Spec.Environment.Name = pkg.Spec.Environment.Name function.Spec.Environment.Namespace = pkg.Spec.Environment.Namespace } diff --git a/pkg/fission-cli/cmd/httptrigger/create.go b/pkg/fission-cli/cmd/httptrigger/create.go index 75d726a4..7f9d424f 100644 --- a/pkg/fission-cli/cmd/httptrigger/create.go +++ b/pkg/fission-cli/cmd/httptrigger/create.go @@ -29,9 +29,8 @@ import ( "github.com/fission/fission/pkg/controller/client" ferror "github.com/fission/fission/pkg/error" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/spec" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -41,8 +40,12 @@ type CreateSubCommand struct { } func Create(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := CreateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -101,7 +104,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { if !flags.Bool("spec") { err = util.CheckFunctionExistence(opts.client, functionList, fnNamespace) if err != nil { - log.Warn(err.Error()) + consolemsg.Warn(err.Error()) } } @@ -115,7 +118,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { host := flags.String("host") if flags.IsSet("host") { - log.Warn(fmt.Sprintf("--host is now marked as deprecated, see 'help' for details")) + consolemsg.Warn(fmt.Sprintf("--host is now marked as deprecated, see 'help' for details")) } // just name triggers by uuid. diff --git a/pkg/fission-cli/cmd/httptrigger/delete.go b/pkg/fission-cli/cmd/httptrigger/delete.go index 3aefeb22..1105cb18 100644 --- a/pkg/fission-cli/cmd/httptrigger/delete.go +++ b/pkg/fission-cli/cmd/httptrigger/delete.go @@ -19,13 +19,12 @@ package httptrigger import ( "fmt" + "github.com/fission/fission/pkg/controller/client" + "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" + "github.com/fission/fission/pkg/fission-cli/util" "github.com/hashicorp/go-multierror" "github.com/pkg/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - "github.com/fission/fission/pkg/controller/client" - "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" ) type DeleteSubCommand struct { @@ -36,8 +35,12 @@ type DeleteSubCommand struct { } func Delete(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := DeleteSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/httptrigger/get.go b/pkg/fission-cli/cmd/httptrigger/get.go index 6c41b801..be78f4a5 100644 --- a/pkg/fission-cli/cmd/httptrigger/get.go +++ b/pkg/fission-cli/cmd/httptrigger/get.go @@ -28,7 +28,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type GetSubCommand struct { @@ -38,8 +38,12 @@ type GetSubCommand struct { } func Get(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := GetSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/httptrigger/list.go b/pkg/fission-cli/cmd/httptrigger/list.go index 3996fcdd..6de11097 100644 --- a/pkg/fission-cli/cmd/httptrigger/list.go +++ b/pkg/fission-cli/cmd/httptrigger/list.go @@ -22,7 +22,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type ListSubCommand struct { @@ -32,8 +32,12 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ListSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/httptrigger/update.go b/pkg/fission-cli/cmd/httptrigger/update.go index 3396aa6e..6007efad 100644 --- a/pkg/fission-cli/cmd/httptrigger/update.go +++ b/pkg/fission-cli/cmd/httptrigger/update.go @@ -25,8 +25,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -36,8 +35,12 @@ type UpdateSubCommand struct { } func Update(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := UpdateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -70,7 +73,7 @@ func (opts *UpdateSubCommand) complete(flags cli.Input) error { functionList := flags.StringSlice("function") err := util.CheckFunctionExistence(opts.client, functionList, triggerNamespace) if err != nil { - log.Warn(err.Error()) + consolemsg.Warn(err.Error()) } var functionWeightsList []int @@ -93,7 +96,7 @@ func (opts *UpdateSubCommand) complete(flags cli.Input) error { if flags.IsSet("host") { ht.Spec.Host = flags.String("host") - log.Warn(fmt.Sprintf("--host is now marked as deprecated, see 'help' for details")) + consolemsg.Warn(fmt.Sprintf("--host is now marked as deprecated, see 'help' for details")) } if flags.IsSet("ingressrule") || flags.IsSet("ingressannotation") || flags.IsSet("ingresstls") { diff --git a/pkg/fission-cli/cmd/kubewatch/create.go b/pkg/fission-cli/cmd/kubewatch/create.go index f2e1b01c..dbd2327e 100644 --- a/pkg/fission-cli/cmd/kubewatch/create.go +++ b/pkg/fission-cli/cmd/kubewatch/create.go @@ -26,9 +26,8 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/spec" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/util" ) type CreateSubCommand struct { @@ -37,8 +36,12 @@ type CreateSubCommand struct { } func Create(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := CreateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -54,7 +57,7 @@ func (opts *CreateSubCommand) do(flags cli.Input) error { func (opts *CreateSubCommand) complete(flags cli.Input) error { fnName := flags.String("function") if len(fnName) == 0 { - log.Fatal("Need a function name to create a watch, use --function") + return errors.New("Need a function name to create a watch, use --function") } fnNamespace := flags.String("fnNamespace") diff --git a/pkg/fission-cli/cmd/kubewatch/delete.go b/pkg/fission-cli/cmd/kubewatch/delete.go index 780559e3..bd55e637 100644 --- a/pkg/fission-cli/cmd/kubewatch/delete.go +++ b/pkg/fission-cli/cmd/kubewatch/delete.go @@ -24,7 +24,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type DeleteSubCommand struct { @@ -34,8 +34,12 @@ type DeleteSubCommand struct { } func Delete(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := DeleteSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/kubewatch/list.go b/pkg/fission-cli/cmd/kubewatch/list.go index e4ca9191..4a7c1d20 100644 --- a/pkg/fission-cli/cmd/kubewatch/list.go +++ b/pkg/fission-cli/cmd/kubewatch/list.go @@ -25,7 +25,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type ListSubCommand struct { @@ -34,8 +34,12 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ListSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/mqtrigger/create.go b/pkg/fission-cli/cmd/mqtrigger/create.go index 3593a311..7368096c 100644 --- a/pkg/fission-cli/cmd/mqtrigger/create.go +++ b/pkg/fission-cli/cmd/mqtrigger/create.go @@ -26,9 +26,8 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/spec" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/util" "github.com/fission/fission/pkg/types" ) @@ -38,8 +37,12 @@ type CreateSubCommand struct { } func Create(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := CreateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -59,7 +62,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { } fnName := flags.String("function") if len(fnName) == 0 { - log.Fatal("Need a function name to create a trigger, use --function") + return errors.New("Need a function name to create a trigger, use --function") } fnNamespace := flags.String("fnNamespace") @@ -73,23 +76,21 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { mqType = types.MessageQueueTypeASQ case types.MessageQueueTypeKafka: mqType = types.MessageQueueTypeKafka - default: - log.Fatal("Unknown message queue type, currently only \"nats-streaming, azure-storage-queue, kafka \" is supported") - + return errors.New("Unknown message queue type, currently only \"nats-streaming, azure-storage-queue, kafka \" is supported") } // TODO: check topic availability topic := flags.String("topic") if len(topic) == 0 { - log.Fatal("Topic cannot be empty") + return errors.New("Topic cannot be empty") } respTopic := flags.String("resptopic") if topic == respTopic { // TODO maybe this should just be a warning, perhaps // allow it behind a --force flag - log.Fatal("Listen topic should not equal to response topic") + return errors.New("Listen topic should not equal to response topic") } errorTopic := flags.String("errortopic") @@ -97,7 +98,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { maxRetries := flags.Int("maxretries") if maxRetries < 0 { - log.Fatal("Maximum number of retries must be a natural number, default is 0") + return errors.New("Maximum number of retries must be a natural number, default is 0") } contentType := flags.String("contenttype") diff --git a/pkg/fission-cli/cmd/mqtrigger/delete.go b/pkg/fission-cli/cmd/mqtrigger/delete.go index 9b194de6..145c21f5 100644 --- a/pkg/fission-cli/cmd/mqtrigger/delete.go +++ b/pkg/fission-cli/cmd/mqtrigger/delete.go @@ -24,7 +24,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type DeleteSubCommand struct { @@ -33,8 +33,12 @@ type DeleteSubCommand struct { } func Delete(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := DeleteSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -48,7 +52,7 @@ func (opts *DeleteSubCommand) do(flags cli.Input) error { } func (opts *DeleteSubCommand) complete(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "triggerns", flags) + m, err := util.GetMetadata("name", "triggerns", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/mqtrigger/list.go b/pkg/fission-cli/cmd/mqtrigger/list.go index 866a26e6..b4ecec60 100644 --- a/pkg/fission-cli/cmd/mqtrigger/list.go +++ b/pkg/fission-cli/cmd/mqtrigger/list.go @@ -25,7 +25,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type ListSubCommand struct { @@ -34,8 +34,12 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ListSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/mqtrigger/update.go b/pkg/fission-cli/cmd/mqtrigger/update.go index 6091212d..d089f2b1 100644 --- a/pkg/fission-cli/cmd/mqtrigger/update.go +++ b/pkg/fission-cli/cmd/mqtrigger/update.go @@ -24,7 +24,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type UpdateSubCommand struct { @@ -33,8 +33,12 @@ type UpdateSubCommand struct { } func Update(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := UpdateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -48,7 +52,7 @@ func (opts *UpdateSubCommand) do(flags cli.Input) error { } func (opts *UpdateSubCommand) complete(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "triggerns", flags) + m, err := util.GetMetadata("name", "triggerns", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/package/create.go b/pkg/fission-cli/cmd/package/create.go index f1869343..e9a63389 100644 --- a/pkg/fission-cli/cmd/package/create.go +++ b/pkg/fission-cli/cmd/package/create.go @@ -23,16 +23,14 @@ import ( "time" "github.com/dchest/uniuri" + "github.com/pkg/errors" uuid "github.com/satori/go.uuid" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" - cmdutils "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/spec" - "github.com/fission/fission/pkg/fission-cli/log" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -41,8 +39,12 @@ type CreateSubCommand struct { } func Create(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := CreateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -60,7 +62,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { pkgNamespace := flags.String("pkgNamespace") envName := flags.String("env") if len(envName) == 0 { - log.Fatal("Need --env argument.") + return errors.New("Need --env argument.") } envNamespace := flags.String("envNamespace") srcArchiveFiles := flags.StringSlice("src") @@ -69,7 +71,7 @@ func (opts *CreateSubCommand) complete(flags cli.Input) error { keepURL := flags.Bool("keepurl") if len(srcArchiveFiles) == 0 && len(deployArchiveFiles) == 0 { - log.Fatal("Need --src to specify source archive, or use --deploy to specify deployment archive.") + return errors.New("Need --src to specify source archive, or use --deploy to specify deployment archive.") } _, err := CreatePackage(flags, opts.client, pkgNamespace, envName, envNamespace, @@ -132,19 +134,25 @@ func CreatePackage(flags cli.Input, client *client.Client, pkgNamespace string, if len(specFile) > 0 { // if a package sith the same spec exists, don't create a new spec file - fr, err := spec.ReadSpecs(cmdutils.GetSpecDir(flags)) - util.CheckErr(err, "read specs") + fr, err := spec.ReadSpecs(util.GetSpecDir(flags)) + if err != nil { + return nil, errors.Wrap(err, "error reading specs") + } if m := fr.SpecExists(pkg, false, true); m != nil { fmt.Printf("Re-using previously created package %v\n", m.Name) return m, nil } err = spec.SpecSave(*pkg, specFile) - util.CheckErr(err, "save package spec") + if err != nil { + return nil, errors.Wrap(err, "error saving package spec") + } return &pkg.Metadata, nil } else { pkgMetadata, err := client.PackageCreate(pkg) - util.CheckErr(err, "create package") + if err != nil { + return nil, errors.Wrap(err, "error creating package") + } fmt.Printf("Package '%v' created\n", pkgMetadata.GetName()) return pkgMetadata, nil } diff --git a/pkg/fission-cli/cmd/package/delete.go b/pkg/fission-cli/cmd/package/delete.go index 4ac3e01f..d9178836 100644 --- a/pkg/fission-cli/cmd/package/delete.go +++ b/pkg/fission-cli/cmd/package/delete.go @@ -24,7 +24,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - cmdutils "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type DeleteSubCommand struct { @@ -36,8 +36,12 @@ type DeleteSubCommand struct { } func Delete(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := DeleteSubCommand{ - client: cmdutils.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/package/get.go b/pkg/fission-cli/cmd/package/get.go index 9e0864bf..05ad9e31 100644 --- a/pkg/fission-cli/cmd/package/get.go +++ b/pkg/fission-cli/cmd/package/get.go @@ -27,8 +27,8 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - cmdutils "github.com/fission/fission/pkg/fission-cli/cmd" pkgutil "github.com/fission/fission/pkg/fission-cli/cmd/package/util" + "github.com/fission/fission/pkg/fission-cli/util" ) const ( @@ -45,16 +45,24 @@ type GetSubCommand struct { } func GetSrc(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := GetSubCommand{ - client: cmdutils.GetServer(flags), + client: c, archiveType: sourceArchive, } return opts.do(flags) } func GetDeploy(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := GetSubCommand{ - client: cmdutils.GetServer(flags), + client: c, archiveType: deployArchive, } return opts.do(flags) @@ -96,7 +104,10 @@ func (opts *GetSubCommand) run(flags cli.Input) error { if pkg.Spec.Deployment.Type == fv1.ArchiveTypeLiteral { reader = bytes.NewReader(archive.Literal) } else if pkg.Spec.Deployment.Type == fv1.ArchiveTypeUrl { - readCloser := pkgutil.DownloadStoragesvcURL(opts.client, archive.URL) + readCloser, err := pkgutil.DownloadStoragesvcURL(opts.client, archive.URL) + if err != nil { + return err + } defer readCloser.Close() reader = readCloser } diff --git a/pkg/fission-cli/cmd/package/info.go b/pkg/fission-cli/cmd/package/info.go index fe0c0359..b59a606a 100644 --- a/pkg/fission-cli/cmd/package/info.go +++ b/pkg/fission-cli/cmd/package/info.go @@ -21,12 +21,11 @@ import ( "os" "text/tabwriter" + "github.com/pkg/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - cmdutils "github.com/fission/fission/pkg/fission-cli/cmd" - "github.com/fission/fission/pkg/fission-cli/log" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -37,8 +36,12 @@ type InfoSubCommand struct { } func Info(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := InfoSubCommand{ - client: cmdutils.GetServer(flags), + client: c, } return opts.do(flags) } @@ -54,7 +57,7 @@ func (opts *InfoSubCommand) do(flags cli.Input) error { func (opts *InfoSubCommand) complete(flags cli.Input) error { opts.name = flags.String("name") if len(opts.name) == 0 { - log.Fatal("Need name of package, use --name") + return errors.New("Need name of package, use --name") } opts.namespace = flags.String("pkgNamespace") return nil @@ -66,7 +69,7 @@ func (opts *InfoSubCommand) run(flags cli.Input) error { Name: opts.name, }) if err != nil { - util.CheckErr(err, fmt.Sprintf("find package %s", opts.name)) + return errors.Wrapf(err, "error finding package %s", opts.name) } w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0) diff --git a/pkg/fission-cli/cmd/package/list.go b/pkg/fission-cli/cmd/package/list.go index e86e0a8a..140ea3cb 100644 --- a/pkg/fission-cli/cmd/package/list.go +++ b/pkg/fission-cli/cmd/package/list.go @@ -27,7 +27,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - cmdutils "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type ListSubCommand struct { @@ -38,8 +38,12 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ListSubCommand{ - client: cmdutils.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/package/package.go b/pkg/fission-cli/cmd/package/package.go index 80f356c5..dd96652e 100644 --- a/pkg/fission-cli/cmd/package/package.go +++ b/pkg/fission-cli/cmd/package/package.go @@ -61,7 +61,7 @@ func CreateArchive(client *client.Client, includeFiles []string, noZip bool, kee // Get files from inputs as number of files decide next steps files, err := utils.FindAllGlobs([]string{path}) if err != nil { - util.CheckErr(err, "finding all globs") + return nil, errors.Wrap(err, "error finding all globs") } if len(files) == 0 { @@ -90,14 +90,18 @@ func CreateArchive(client *client.Client, includeFiles []string, noZip bool, kee // check if this AUS exists in the specs; if so, don't create a new one fr, err := spec.ReadSpecs(specDir) - util.CheckErr(err, "read specs") + if err != nil { + return nil, errors.Wrap(err, "error reading specs") + } if m := fr.SpecExists(aus, false, true); m != nil { fmt.Printf("Re-using previously created archive %v\n", m.Name) aus.Name = m.Name } else { // save the uploadspec err := spec.SpecSave(*aus, specFile) - util.CheckErr(err, fmt.Sprintf("write spec file %v", specFile)) + if err != nil { + return nil, errors.Wrapf(err, "write spec file %v", specFile) + } } // create the archive object @@ -118,11 +122,18 @@ func CreateArchive(client *client.Client, includeFiles []string, noZip bool, kee }, nil } // download the file before we archive it - dst := pkgutil.DownloadToTempFile(fileURL) + dst, err := pkgutil.DownloadToTempFile(fileURL) + if err != nil { + return nil, err + } includeFiles = []string{dst} } - archivePath := makeArchiveFile("", includeFiles, noZip) + archivePath, err := makeArchiveFile("", includeFiles, noZip) + if err != nil { + return nil, err + } + ctx := context.Background() return pkgutil.UploadArchiveFile(ctx, client, archivePath) } @@ -134,7 +145,7 @@ func CreateArchive(client *client.Client, includeFiles []string, noZip bool, kee // returned as-is with no zipping. (This is used for compatibility // with v1 envs.) noZip is IGNORED if there is more than one input // file. -func makeArchiveFile(archiveNameHint string, archiveInput []string, noZip bool) string { +func makeArchiveFile(archiveNameHint string, archiveInput []string, noZip bool) (string, error) { // Unique name for the archive archiveName := archiveName(archiveNameHint, archiveInput) @@ -142,34 +153,34 @@ func makeArchiveFile(archiveNameHint string, archiveInput []string, noZip bool) // Get files from inputs as number of files decide next steps files, err := utils.FindAllGlobs(archiveInput) if err != nil { - util.CheckErr(err, "finding all globs") + return "", errors.Wrap(err, "error finding all globs") } // We have one file; if it's a zip file, no need to archive it if len(files) == 1 { // make sure it exists if _, err := os.Stat(files[0]); err != nil { - util.CheckErr(err, fmt.Sprintf("open input file %v", files[0])) + return "", errors.Wrapf(err, "open input file %v", files[0]) } // if it's an existing zip file OR we're not supposed to zip it, don't do anything if archiver.Zip.Match(files[0]) || noZip { - return files[0] + return files[0], nil } } // For anything else, create a new archive tmpDir, err := utils.GetTempDir() if err != nil { - util.CheckErr(err, "create temporary archive directory") + return "", errors.Wrap(err, "error create temporary archive directory") } archivePath, err := utils.MakeZipArchive(filepath.Join(tmpDir, archiveName), archiveInput...) if err != nil { - util.CheckErr(err, "create archive file") + return "", errors.Wrap(err, "create archive file") } - return archivePath + return archivePath, nil } // Name an archive diff --git a/pkg/fission-cli/cmd/package/rebuild.go b/pkg/fission-cli/cmd/package/rebuild.go index 62cc9579..bd45786a 100644 --- a/pkg/fission-cli/cmd/package/rebuild.go +++ b/pkg/fission-cli/cmd/package/rebuild.go @@ -25,7 +25,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - cmdutils "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type RebuildSubCommand struct { @@ -35,8 +35,12 @@ type RebuildSubCommand struct { } func Rebuild(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := RebuildSubCommand{ - client: cmdutils.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/package/update.go b/pkg/fission-cli/cmd/package/update.go index dc1afbad..df944d21 100644 --- a/pkg/fission-cli/cmd/package/update.go +++ b/pkg/fission-cli/cmd/package/update.go @@ -26,7 +26,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type UpdateSubCommand struct { @@ -43,8 +43,12 @@ type UpdateSubCommand struct { } func Update(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := UpdateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/package/util/util.go b/pkg/fission-cli/cmd/package/util/util.go index 5de6efc0..6687894f 100644 --- a/pkg/fission-cli/cmd/package/util/util.go +++ b/pkg/fission-cli/cmd/package/util/util.go @@ -26,11 +26,11 @@ import ( "path/filepath" "strings" + "github.com/pkg/errors" uuid "github.com/satori/go.uuid" fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" - "github.com/fission/fission/pkg/fission-cli/util" storageSvcClient "github.com/fission/fission/pkg/storagesvc/client" "github.com/fission/fission/pkg/types" "github.com/fission/fission/pkg/utils" @@ -46,18 +46,25 @@ func UploadArchiveFile(ctx context.Context, client *client.Client, fileName stri if size < types.ArchiveLiteralSizeLimit { archive.Type = fv1.ArchiveTypeLiteral - archive.Literal = GetContents(fileName) + archive.Literal, err = GetContents(fileName) + if err != nil { + return nil, err + } } else { u := strings.TrimSuffix(client.Url, "/") + "/proxy/storage" ssClient := storageSvcClient.MakeClient(u) // TODO add a progress bar id, err := ssClient.Upload(ctx, fileName, nil) - util.CheckErr(err, fmt.Sprintf("upload file %v", fileName)) + if err != nil { + return nil, errors.Wrapf(err, "error uploading file %v", fileName) + } storageSvc, err := client.GetSvcURL("application=fission-storage") storageSvcURL := "http://" + storageSvc - util.CheckErr(err, "get fission storage service name") + if err != nil { + return nil, errors.Wrapf(err, "error getting fission storage service name") + } // We make a new client with actual URL of Storage service so that the URL is not // pointing to 127.0.0.1 i.e. proxy. DON'T reuse previous ssClient @@ -68,7 +75,9 @@ func UploadArchiveFile(ctx context.Context, client *client.Client, fileName stri archive.URL = archiveURL csum, err := utils.GetFileChecksum(fileName) - util.CheckErr(err, fmt.Sprintf("calculate checksum for file %v", fileName)) + if err != nil { + return nil, errors.Wrapf(err, "calculate checksum for file %v", fileName) + } archive.Checksum = *csum } @@ -76,32 +85,37 @@ func UploadArchiveFile(ctx context.Context, client *client.Client, fileName stri return &archive, nil } -func GetContents(filePath string) []byte { - var code []byte - var err error - - code, err = ioutil.ReadFile(filePath) - util.CheckErr(err, fmt.Sprintf("read %v", filePath)) - return code +func GetContents(filePath string) ([]byte, error) { + code, err := ioutil.ReadFile(filePath) + if err != nil { + return nil, errors.Wrapf(err, "error reading %v", filePath) + } + return code, nil } // DownloadToTempFile fetches archive file from arbitrary url // and write it to temp file for further usage -func DownloadToTempFile(fileUrl string) string { +func DownloadToTempFile(fileUrl string) (string, error) { reader, err := DownloadURL(fileUrl) - util.CheckErr(err, fmt.Sprintf("download from url: %v", fileUrl)) + if err != nil { + return "", errors.Wrapf(err, "error downloading from url: %v", fileUrl) + } defer reader.Close() tmpDir, err := utils.GetTempDir() - util.CheckErr(err, "create temp directory") + if err != nil { + return "", errors.Wrapf(err, "error creating temp directory %v", tmpDir) + } tmpFilename := uuid.NewV4().String() destination := filepath.Join(tmpDir, tmpFilename) err = WriteArchiveToFile(destination, reader) - util.CheckErr(err, "write archive to file") + if err != nil { + return "", errors.Wrapf(err, "error writing archive to file %v", destination) + } - return destination + return destination, nil } // DownloadURL downloads file from given url @@ -146,16 +160,18 @@ func WriteArchiveToFile(fileName string, reader io.Reader) error { } // DownloadStoragesvcURL downloads and return archive content with given storage service url -func DownloadStoragesvcURL(client *client.Client, fileUrl string) io.ReadCloser { +func DownloadStoragesvcURL(client *client.Client, fileUrl string) (io.ReadCloser, error) { u, err := url.ParseRequestURI(fileUrl) if err != nil { - return nil + return nil, err } // replace in-cluster storage service host with controller server url fileDownloadUrl := strings.TrimSuffix(client.Url, "/") + "/proxy/storage/" + u.RequestURI() reader, err := DownloadURL(fileDownloadUrl) + if err != nil { + return nil, errors.Wrapf(err, fmt.Sprintf("error downloading from storage service url: %v", fileUrl)) + } - util.CheckErr(err, fmt.Sprintf("download from storage service url: %v", fileUrl)) - return reader + return reader, nil } diff --git a/pkg/fission-cli/cmd/plugin/list.go b/pkg/fission-cli/cmd/plugin/list.go index 0f93d694..90c54c0d 100644 --- a/pkg/fission-cli/cmd/plugin/list.go +++ b/pkg/fission-cli/cmd/plugin/list.go @@ -23,7 +23,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" "github.com/fission/fission/pkg/plugin" ) @@ -32,8 +32,12 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := &ListSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/recorder/create.go b/pkg/fission-cli/cmd/recorder/create.go index d93fa78d..d51523ed 100644 --- a/pkg/fission-cli/cmd/recorder/create.go +++ b/pkg/fission-cli/cmd/recorder/create.go @@ -27,8 +27,8 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/spec" + "github.com/fission/fission/pkg/fission-cli/util" ) type CreateSubCommand struct { @@ -37,8 +37,12 @@ type CreateSubCommand struct { } func Create(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := CreateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/recorder/delete.go b/pkg/fission-cli/cmd/recorder/delete.go index eb49d440..45e44be4 100644 --- a/pkg/fission-cli/cmd/recorder/delete.go +++ b/pkg/fission-cli/cmd/recorder/delete.go @@ -24,7 +24,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type DeleteSubCommand struct { @@ -33,8 +33,12 @@ type DeleteSubCommand struct { } func Delete(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := DeleteSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -48,7 +52,7 @@ func (opts *DeleteSubCommand) do(flags cli.Input) error { } func (opts *DeleteSubCommand) complete(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "recorderns", flags) + m, err := util.GetMetadata("name", "recorderns", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/recorder/get.go b/pkg/fission-cli/cmd/recorder/get.go index 4681a745..7cd859ba 100644 --- a/pkg/fission-cli/cmd/recorder/get.go +++ b/pkg/fission-cli/cmd/recorder/get.go @@ -26,7 +26,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type GetSubCommand struct { @@ -35,8 +35,12 @@ type GetSubCommand struct { } func Get(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := GetSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/recorder/list.go b/pkg/fission-cli/cmd/recorder/list.go index 5d28e2aa..cd311b77 100644 --- a/pkg/fission-cli/cmd/recorder/list.go +++ b/pkg/fission-cli/cmd/recorder/list.go @@ -25,7 +25,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type ListSubCommand struct { @@ -33,8 +33,12 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ListSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/recorder/update.go b/pkg/fission-cli/cmd/recorder/update.go index ff551620..95bb3f67 100644 --- a/pkg/fission-cli/cmd/recorder/update.go +++ b/pkg/fission-cli/cmd/recorder/update.go @@ -26,7 +26,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type UpdateSubCommand struct { @@ -35,8 +35,12 @@ type UpdateSubCommand struct { } func Update(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := UpdateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/records/view.go b/pkg/fission-cli/cmd/records/view.go index bf4a0fb9..075d112b 100644 --- a/pkg/fission-cli/cmd/records/view.go +++ b/pkg/fission-cli/cmd/records/view.go @@ -25,7 +25,6 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/util" redisCache "github.com/fission/fission/pkg/redis/build/gen" ) @@ -35,8 +34,12 @@ type ViewSubCommand struct { } func View(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ViewSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -68,71 +71,55 @@ func (opts *ViewSubCommand) run(flags cli.Input) error { } if len(function) != 0 { - return recordsByFunction(function, verbosity, flags) + return recordsByFunction(opts.client, function, verbosity) } if len(trigger) != 0 { - return recordsByTrigger(trigger, verbosity, flags) + return recordsByTrigger(opts.client, trigger, verbosity) } if len(from) != 0 && len(to) != 0 { - return recordsByTime(from, to, verbosity, flags) + return recordsByTime(opts.client, from, to, verbosity) } - err := recordsAll(verbosity, flags) + err := recordsAll(opts.client, verbosity) if err != nil { return errors.Wrap(err, "error viewing records") } return nil } -func recordsAll(verbosity int, flags cli.Input) error { - fc := util.GetApiClient(flags.GlobalString("server")) - - records, err := fc.RecordsAll() +func recordsAll(client *client.Client, verbosity int) error { + records, err := client.RecordsAll() if err != nil { return errors.Wrap(err, "error viewing records") } - showRecords(records, verbosity) - return nil } -func recordsByTrigger(trigger string, verbosity int, flags cli.Input) error { - fc := util.GetApiClient(flags.GlobalString("server")) - - records, err := fc.RecordsByTrigger(trigger) +func recordsByTrigger(client *client.Client, trigger string, verbosity int) error { + records, err := client.RecordsByTrigger(trigger) if err != nil { return errors.Wrap(err, "error viewing records") } - showRecords(records, verbosity) - return nil } // TODO: More accurate function name (function filter) -func recordsByFunction(function string, verbosity int, flags cli.Input) error { - fc := util.GetApiClient(flags.GlobalString("server")) - - records, err := fc.RecordsByFunction(function) +func recordsByFunction(client *client.Client, function string, verbosity int) error { + records, err := client.RecordsByFunction(function) if err != nil { return errors.Wrap(err, "error viewing records") } - showRecords(records, verbosity) - return nil } -func recordsByTime(from string, to string, verbosity int, flags cli.Input) error { - fc := util.GetApiClient(flags.GlobalString("server")) - - records, err := fc.RecordsByTime(from, to) +func recordsByTime(client *client.Client, from string, to string, verbosity int) error { + records, err := client.RecordsByTime(from, to) if err != nil { return errors.Wrap(err, "error viewing records") } - showRecords(records, verbosity) - return nil } diff --git a/pkg/fission-cli/cmd/replay/replay.go b/pkg/fission-cli/cmd/replay/replay.go index f616269c..87afbaa1 100644 --- a/pkg/fission-cli/cmd/replay/replay.go +++ b/pkg/fission-cli/cmd/replay/replay.go @@ -25,7 +25,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type ReplaySubCommand struct { @@ -33,8 +33,12 @@ type ReplaySubCommand struct { } func Replay(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ReplaySubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/spec/apply.go b/pkg/fission-cli/cmd/spec/apply.go index 62854151..85328122 100644 --- a/pkg/fission-cli/cmd/spec/apply.go +++ b/pkg/fission-cli/cmd/spec/apply.go @@ -34,10 +34,10 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + pkgutil "github.com/fission/fission/pkg/fission-cli/cmd/package/util" spectypes "github.com/fission/fission/pkg/fission-cli/cmd/spec/types" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" "github.com/fission/fission/pkg/fission-cli/util" "github.com/fission/fission/pkg/types" "github.com/fission/fission/pkg/utils" @@ -57,8 +57,12 @@ type ApplySubCommand struct { // etc, while doing an apply, they will get a partially applied deployment. However, // they can retry their apply command once they're back online. func Apply(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ApplySubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -68,7 +72,7 @@ func (opts *ApplySubCommand) do(flags cli.Input) error { } func (opts *ApplySubCommand) run(flags cli.Input) error { - specDir := cmd.GetSpecDir(flags) + specDir := util.GetSpecDir(flags) deleteResources := flags.Bool("delete") watchResources := flags.Bool("watch") @@ -85,35 +89,50 @@ func (opts *ApplySubCommand) run(flags cli.Input) error { if watchResources { var err error watcher, err = fsnotify.NewWatcher() - util.CheckErr(err, "create file watcher") + if err != nil { + return errors.Wrap(err, "error creating file watcher") + } // add watches rootDir := filepath.Clean(specDir + "/..") err = filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error { - util.CheckErr(err, "scan project files") + if err != nil { + return errors.Wrap(err, "error scanning project files") + } if ignoreFile(path) { return nil } + err = watcher.Add(path) - util.CheckErr(err, fmt.Sprintf("watch path %v", path)) + if err != nil { + return errors.Wrap(err, fmt.Sprintf("error watching path %v", path)) + } return nil }) - util.CheckErr(err, "scan files to watch") + if err != nil { + return errors.Wrap(err, "error scanning files to watch") + } } for { // read all specs fr, err := ReadSpecs(specDir) - util.CheckErr(err, "read specs") + if err != nil { + return errors.Wrap(err, "error reading specs") + } // validate err = fr.Validate(flags) - util.CheckErr(err, "validate specs") + if err != nil { + return errors.Wrap(err, "error validating specs") + } // make changes to the cluster based on the specs pkgMetas, as, err := applyResources(opts.client, specDir, fr, deleteResources) - util.CheckErr(err, "apply specs") + if err != nil { + return errors.Wrap(err, "error applying specs") + } printApplyStatus(as) if watchResources || waitForBuild { @@ -146,7 +165,6 @@ func (opts *ApplySubCommand) run(flags cli.Input) error { if ignoreFile(e.Name) { continue waitloop } - fmt.Printf("Noticed a file change, reapplying specs...\n") // Builds that finish after this cancellation will be @@ -154,11 +172,17 @@ func (opts *ApplySubCommand) run(flags cli.Input) error { pkgWatchCancel() err = waitForFileWatcherToSettleDown(watcher) - util.CheckErr(err, "watching files") - + if err != nil { + return errors.Wrap(err, "error watching files") + } break waitloop + case err := <-watcher.Errors: - util.CheckErr(err, "watching files") + pkgWatchCancel() + + if err != nil { + return errors.Wrap(err, "error watching files") + } } } } @@ -406,7 +430,7 @@ func localArchiveFromSpec(specDir string, aus *spectypes.ArchiveUploadSpec) (*fv absGlob := rootDir + "/" + relativeGlob f, err := filepath.Glob(absGlob) if err != nil { - log.Info(fmt.Sprintf("Invalid glob in archive %v: %v", aus.Name, relativeGlob)) + consolemsg.Info(fmt.Sprintf("Invalid glob in archive %v: %v", aus.Name, relativeGlob)) return nil, err } files = append(files, f...) @@ -454,7 +478,10 @@ func localArchiveFromSpec(specDir string, aus *spectypes.ArchiveUploadSpec) (*fv // figure out if we're making a literal or a URL-based archive if size < types.ArchiveLiteralSizeLimit { - contents := pkgutil.GetContents(archiveFileName) + contents, err := pkgutil.GetContents(archiveFileName) + if err != nil { + return nil, err + } return &fv1.Archive{ Type: fv1.ArchiveTypeLiteral, Literal: contents, diff --git a/pkg/fission-cli/cmd/spec/buildwatch.go b/pkg/fission-cli/cmd/spec/buildwatch.go index 58137659..81149970 100644 --- a/pkg/fission-cli/cmd/spec/buildwatch.go +++ b/pkg/fission-cli/cmd/spec/buildwatch.go @@ -19,13 +19,13 @@ package spec import ( "context" "fmt" + "os" "time" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" - "github.com/fission/fission/pkg/fission-cli/util" "github.com/fission/fission/pkg/types" ) @@ -68,7 +68,10 @@ func (w *packageBuildWatcher) watch(ctx context.Context) { // pull list of packages (TODO: convert to watch) pkgs, err := w.fclient.PackageList(metav1.NamespaceAll) - util.CheckErr(err, "Getting list of packages") + if err != nil { + fmt.Printf("Getting list of packages: %v", err) + os.Exit(1) + } // find packages that (a) are in the app spec and (b) have an interesting // build status (either succeeded or failed; not "none") diff --git a/pkg/fission-cli/cmd/spec/destroy.go b/pkg/fission-cli/cmd/spec/destroy.go index 0a8e1ff5..ef05296e 100644 --- a/pkg/fission-cli/cmd/spec/destroy.go +++ b/pkg/fission-cli/cmd/spec/destroy.go @@ -17,9 +17,10 @@ limitations under the License. package spec import ( + "github.com/pkg/errors" + "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -29,8 +30,12 @@ type DestroySubCommand struct { // Destroy destroys everything in the spec. func Destroy(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := &DestroySubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -41,11 +46,13 @@ func (opts *DestroySubCommand) do(flags cli.Input) error { func (opts *DestroySubCommand) run(flags cli.Input) error { // get specdir - specDir := cmd.GetSpecDir(flags) + specDir := util.GetSpecDir(flags) // read everything fr, err := ReadSpecs(specDir) - util.CheckErr(err, "read specs") + if err != nil { + return errors.Wrap(err, "error reading specs") + } // set desired state to nothing, but keep the UID so "apply" can find it emptyFr := FissionResources{} @@ -53,7 +60,9 @@ func (opts *DestroySubCommand) run(flags cli.Input) error { // "apply" the empty state _, _, err = applyResources(opts.client, specDir, &emptyFr, true) - util.CheckErr(err, "delete resources") + if err != nil { + return errors.Wrap(err, "error deleting resources") + } return nil } diff --git a/pkg/fission-cli/cmd/spec/init.go b/pkg/fission-cli/cmd/spec/init.go index 74749b88..9b163683 100644 --- a/pkg/fission-cli/cmd/spec/init.go +++ b/pkg/fission-cli/cmd/spec/init.go @@ -23,11 +23,11 @@ import ( "path/filepath" "github.com/ghodss/yaml" + "github.com/pkg/errors" uuid "github.com/satori/go.uuid" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" spectypes "github.com/fission/fission/pkg/fission-cli/cmd/spec/types" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -38,8 +38,12 @@ type InitSubCommand struct { } func Init(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := InitSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -54,13 +58,15 @@ func (opts *InitSubCommand) do(flags cli.Input) error { func (opts *InitSubCommand) complete(flags cli.Input) error { // Figure out spec directory - specDir := cmd.GetSpecDir(flags) + specDir := util.GetSpecDir(flags) name := flags.String("name") if len(name) == 0 { // come up with a name using the current dir dir, err := filepath.Abs(".") - util.CheckErr(err, "get current working directory") + if err != nil { + return errors.Wrap(err, "error getting current working directory") + } basename := filepath.Base(dir) name = util.KubifyName(basename) } @@ -73,7 +79,9 @@ func (opts *InitSubCommand) complete(flags cli.Input) error { // Create spec dir fmt.Printf("Creating fission spec directory '%v'\n", specDir) err := os.MkdirAll(specDir, 0755) - util.CheckErr(err, fmt.Sprintf("create spec directory '%v'", specDir)) + if err != nil { + return errors.Wrapf(err, "create spec directory '%v'", specDir) + } // Write the deployment config opts.deployConfig = &spectypes.DeploymentConfig{ @@ -94,7 +102,7 @@ func (opts *InitSubCommand) complete(flags cli.Input) error { // run just initializes an empty spec directory and adds some // sample YAMLs in there that might be useful. func (opts *InitSubCommand) run(flags cli.Input) error { - specDir := cmd.GetSpecDir(flags) + specDir := util.GetSpecDir(flags) // Add a bit of documentation to the spec dir here err := ioutil.WriteFile(filepath.Join(specDir, "README"), []byte(SPEC_README), 0644) @@ -103,7 +111,9 @@ func (opts *InitSubCommand) run(flags cli.Input) error { } err = writeDeploymentConfig(specDir, opts.deployConfig) - util.CheckErr(err, "write deployment config") + if err != nil { + return errors.Wrap(err, "error writing deployment config") + } // Other possible things to do here: // - add example specs to the dir to make it easy to manually diff --git a/pkg/fission-cli/cmd/spec/spec.go b/pkg/fission-cli/cmd/spec/spec.go index 8b079a18..3368a8a0 100644 --- a/pkg/fission-cli/cmd/spec/spec.go +++ b/pkg/fission-cli/cmd/spec/spec.go @@ -31,9 +31,9 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/spec/types" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" + "github.com/fission/fission/pkg/fission-cli/util" "github.com/fission/fission/pkg/generator/encoder" v1generator "github.com/fission/fission/pkg/generator/v1" ) @@ -347,14 +347,17 @@ func (fr *FissionResources) Validate(flags cli.Input) error { packages[MapKey(pkgMeta)] = true } - client := cmd.GetServer(flags) + client, err := util.GetServer(flags) + if err != nil { + return err + } for _, cm := range f.Spec.ConfigMaps { _, err := client.ConfigMapGet(&metav1.ObjectMeta{ Name: cm.Name, Namespace: cm.Namespace, }) if k8serrors.IsNotFound(err) { - log.Warn(fmt.Sprintf("Configmap %s is referred in the spec but not present in the cluster", cm.Name)) + consolemsg.Warn(fmt.Sprintf("Configmap %s is referred in the spec but not present in the cluster", cm.Name)) } } @@ -364,7 +367,7 @@ func (fr *FissionResources) Validate(flags cli.Input) error { Namespace: s.Namespace, }) if k8serrors.IsNotFound(err) { - log.Warn(fmt.Sprintf("Secret %s is referred in the spec but not present in the cluster", s.Name)) + consolemsg.Warn(fmt.Sprintf("Secret %s is referred in the spec but not present in the cluster", s.Name)) } } @@ -392,7 +395,7 @@ func (fr *FissionResources) Validate(flags cli.Input) error { } if len(t.Spec.Host) > 0 { - log.Warn(fmt.Sprintf("Host in HTTPTrigger spec.Host is now marked as deprecated, see 'help' for details")) + consolemsg.Warn(fmt.Sprintf("Host in HTTPTrigger spec.Host is now marked as deprecated, see 'help' for details")) } result = multierror.Append(result, t.Validate()) @@ -427,25 +430,25 @@ func (fr *FissionResources) Validate(flags cli.Input) error { for _, e := range fr.Environments { environments[fmt.Sprintf("%s:%s", e.Metadata.Name, e.Metadata.Namespace)] = struct{}{} if ((e.Spec.Runtime.Container != nil) && (e.Spec.Runtime.PodSpec != nil)) || ((e.Spec.Builder.Container != nil) && (e.Spec.Builder.PodSpec != nil)) { - log.Warn("You have provided both - container spec and pod spec and while merging the pod spec will take precedence.") + consolemsg.Warn("You have provided both - container spec and pod spec and while merging the pod spec will take precedence.") } // Unlike CLI can change the environment version silently, // we have to warn the user to modify spec file when this takes place. if e.Spec.Version < 3 && e.Spec.Poolsize != 0 { - log.Warn("Poolsize can only be configured when environment version equals to 3, default poolsize 3 will be used for creating environment pool.") + consolemsg.Warn("Poolsize can only be configured when environment version equals to 3, default poolsize 3 will be used for creating environment pool.") } } for _, f := range fr.Functions { if _, ok := environments[fmt.Sprintf("%s:%s", f.Spec.Environment.Name, f.Spec.Environment.Namespace)]; !ok { - log.Warn(fmt.Sprintf("Environment %s is referenced in function %s but not declared in specs", f.Spec.Environment.Name, f.Metadata.Name)) + consolemsg.Warn(fmt.Sprintf("Environment %s is referenced in function %s but not declared in specs", f.Spec.Environment.Name, f.Metadata.Name)) } strategy := f.Spec.InvokeStrategy.ExecutionStrategy if strategy.ExecutorType == fv1.ExecutorTypeNewdeploy && strategy.SpecializationTimeout < fv1.DefaultSpecializationTimeOut { - log.Warn(fmt.Sprintf("SpecializationTimeout in function spec.InvokeStrategy.ExecutionStrategy should be a value equal to or greater than %v", fv1.DefaultSpecializationTimeOut)) + consolemsg.Warn(fmt.Sprintf("SpecializationTimeout in function spec.InvokeStrategy.ExecutionStrategy should be a value equal to or greater than %v", fv1.DefaultSpecializationTimeOut)) } if f.Spec.FunctionTimeout <= 0 { - log.Warn(fmt.Sprintf("FunctionTimeout in function spec should be a field which should have a value greater than 0")) + consolemsg.Warn(fmt.Sprintf("FunctionTimeout in function spec should be a field which should have a value greater than 0")) } } @@ -574,7 +577,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location) error { default: // no need to error out just because there's some extra files around; // also good for compatibility. - log.Warn(fmt.Sprintf("Ignoring unknown type %v in %v", tm.Kind, loc)) + consolemsg.Warn(fmt.Sprintf("Ignoring unknown type %v in %v", tm.Kind, loc)) } // add to source map, check for duplicates diff --git a/pkg/fission-cli/cmd/spec/validate.go b/pkg/fission-cli/cmd/spec/validate.go index 1536a4e7..fcc301e0 100644 --- a/pkg/fission-cli/cmd/spec/validate.go +++ b/pkg/fission-cli/cmd/spec/validate.go @@ -18,19 +18,17 @@ package spec import ( "bytes" - "fmt" "io/ioutil" "os" "path/filepath" "strings" "github.com/hashicorp/go-multierror" + "github.com/pkg/errors" fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" - "github.com/fission/fission/pkg/fission-cli/log" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -41,8 +39,12 @@ type ValidateSubCommand struct { // Validate parses a set of specs and checks for references to // resources that don't exist. func Validate(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := &ValidateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -54,16 +56,16 @@ func (opts *ValidateSubCommand) do(flags cli.Input) error { func (opts *ValidateSubCommand) run(flags cli.Input) error { // this will error on parse errors and on duplicates - specDir := cmd.GetSpecDir(flags) + specDir := util.GetSpecDir(flags) fr, err := ReadSpecs(specDir) - util.CheckErr(err, "read specs") + if err != nil { + return errors.Wrap(err, "error reading specs") + } // this does the rest of the checks, like dangling refs err = fr.Validate(flags) if err != nil { - fmt.Printf("Error validating specs: %v", err) - - return nil + return errors.Wrap(err, "error validating specs") } return nil @@ -75,8 +77,8 @@ func ReadSpecs(specDir string) (*FissionResources, error) { // make sure spec directory exists before continue if _, err := os.Stat(specDir); os.IsNotExist(err) { - log.Fatal(fmt.Sprintf("Spec directory %v doesn't exist. "+ - "Please check directory path or run \"fission spec init\" to create it.", specDir)) + return nil, errors.Errorf("Spec directory %v doesn't exist. "+ + "Please check directory path or run \"fission spec init\" to create it.", specDir) } fr := FissionResources{ diff --git a/pkg/fission-cli/cmd/support/dump.go b/pkg/fission-cli/cmd/support/dump.go index c5f42dd2..e21f9d19 100644 --- a/pkg/fission-cli/cmd/support/dump.go +++ b/pkg/fission-cli/cmd/support/dump.go @@ -27,7 +27,6 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/support/resources" "github.com/fission/fission/pkg/fission-cli/util" "github.com/fission/fission/pkg/utils" @@ -43,8 +42,12 @@ type DumpSubCommand struct { } func Dump(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := &DumpSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -71,7 +74,10 @@ func (opts *DumpSubCommand) do(flags cli.Input) error { panic(errors.Wrap(err, "Error creating dump directory for dumping files")) } - _, k8sClient := util.GetKubernetesClient() + _, k8sClient, err := util.GetKubernetesClient() + if err != nil { + return err + } ress := map[string]resources.Resource{ // kubernetes info diff --git a/pkg/fission-cli/cmd/support/resources/crd.go b/pkg/fission-cli/cmd/support/resources/crd.go index e7030752..81b0bb50 100644 --- a/pkg/fission-cli/cmd/support/resources/crd.go +++ b/pkg/fission-cli/cmd/support/resources/crd.go @@ -23,7 +23,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" "github.com/fission/fission/pkg/types" ) @@ -53,7 +53,7 @@ func (res CrdDumper) Dump(dumpDir string) { case CrdEnvironment: items, err := res.client.EnvironmentList(metav1.NamespaceAll) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) return } @@ -65,7 +65,7 @@ func (res CrdDumper) Dump(dumpDir string) { case CrdFunction: items, err := res.client.FunctionList(metav1.NamespaceAll) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) return } @@ -77,7 +77,7 @@ func (res CrdDumper) Dump(dumpDir string) { case CrdPackage: items, err := res.client.PackageList(metav1.NamespaceAll) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) return } @@ -90,7 +90,7 @@ func (res CrdDumper) Dump(dumpDir string) { case CrdHttpTrigger: items, err := res.client.HTTPTriggerList(metav1.NamespaceAll) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) return } @@ -102,7 +102,7 @@ func (res CrdDumper) Dump(dumpDir string) { case CrdKubeWatcher: items, err := res.client.WatchList(metav1.NamespaceAll) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) return } @@ -117,7 +117,7 @@ func (res CrdDumper) Dump(dumpDir string) { for _, mqType := range []string{types.MessageQueueTypeNats, types.MessageQueueTypeASQ} { l, err := res.client.MessageQueueTriggerList(mqType, metav1.NamespaceAll) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) break } triggers = append(triggers, l...) @@ -131,7 +131,7 @@ func (res CrdDumper) Dump(dumpDir string) { case CrdTimeTrigger: items, err := res.client.TimeTriggerList(metav1.NamespaceAll) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list: %v", res.crdType, err)) return } @@ -141,7 +141,7 @@ func (res CrdDumper) Dump(dumpDir string) { } default: - log.Info(fmt.Sprintf("Unknown type: %v", res.crdType)) + consolemsg.Info(fmt.Sprintf("Unknown type: %v", res.crdType)) } } diff --git a/pkg/fission-cli/cmd/support/resources/kubernetes.go b/pkg/fission-cli/cmd/support/resources/kubernetes.go index 8cbc6077..4556a2af 100644 --- a/pkg/fission-cli/cmd/support/resources/kubernetes.go +++ b/pkg/fission-cli/cmd/support/resources/kubernetes.go @@ -28,7 +28,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" ) const ( @@ -52,7 +52,7 @@ func NewKubernetesVersion(clientset *kubernetes.Clientset) Resource { func (res KubernetesVersion) Dump(dumpDir string) { serverVer, err := res.client.ServerVersion() if err != nil { - log.Info(fmt.Sprintf("Error setting up kubernetes client: %v", err)) + consolemsg.Info(fmt.Sprintf("Error setting up kubernetes client: %v", err)) return } @@ -80,7 +80,7 @@ func (res KubernetesObjectDumper) Dump(dumpDir string) { case KubernetesService: objs, err := res.client.CoreV1().Services(metav1.NamespaceAll).List(metav1.ListOptions{LabelSelector: res.selector}) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) return } @@ -93,7 +93,7 @@ func (res KubernetesObjectDumper) Dump(dumpDir string) { case KubernetesDeployment: objs, err := res.client.AppsV1().Deployments(metav1.NamespaceAll).List(metav1.ListOptions{LabelSelector: res.selector}) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) return } @@ -105,7 +105,7 @@ func (res KubernetesObjectDumper) Dump(dumpDir string) { case KubernetesPod: objs, err := res.client.CoreV1().Pods(metav1.NamespaceAll).List(metav1.ListOptions{LabelSelector: res.selector}) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) return } @@ -117,7 +117,7 @@ func (res KubernetesObjectDumper) Dump(dumpDir string) { case KubernetesHPA: objs, err := res.client.AutoscalingV2beta1().HorizontalPodAutoscalers(metav1.NamespaceAll).List(metav1.ListOptions{LabelSelector: res.selector}) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) return } @@ -129,7 +129,7 @@ func (res KubernetesObjectDumper) Dump(dumpDir string) { case KubernetesDaemonSet: objs, err := res.client.AppsV1().DaemonSets(metav1.NamespaceAll).List(metav1.ListOptions{LabelSelector: res.selector}) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) return } @@ -141,7 +141,7 @@ func (res KubernetesObjectDumper) Dump(dumpDir string) { case KubernetesNode: objs, err := res.client.CoreV1().Nodes().List(metav1.ListOptions{LabelSelector: res.selector}) if err != nil { - log.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) + consolemsg.Info(fmt.Sprintf("Error getting %v list with selector %v: %v", res.objType, res.selector, err)) return } @@ -153,7 +153,7 @@ func (res KubernetesObjectDumper) Dump(dumpDir string) { } default: - log.Info(fmt.Sprintf("Unknown type: %v", res.objType)) + consolemsg.Info(fmt.Sprintf("Unknown type: %v", res.objType)) return } } @@ -199,7 +199,7 @@ func (res KubernetesPodLogDumper) Dump(dumpDir string) { Pods(metav1.NamespaceAll). List(metav1.ListOptions{LabelSelector: res.labelSelector}) if err != nil { - log.Info(fmt.Sprintf("Error getting controller list: %v", err)) + consolemsg.Info(fmt.Sprintf("Error getting controller list: %v", err)) return } @@ -218,7 +218,7 @@ func (res KubernetesPodLogDumper) Dump(dumpDir string) { stream, err := req.Stream() if err != nil { - log.Info(fmt.Sprintf("Error streaming logs for pod %v: %v", pod.Name, err)) + consolemsg.Info(fmt.Sprintf("Error streaming logs for pod %v: %v", pod.Name, err)) return } @@ -232,13 +232,13 @@ func (res KubernetesPodLogDumper) Dump(dumpDir string) { stream.Close() break } - log.Info(fmt.Sprintf("Error reading logs from buffer: %v", err)) + consolemsg.Info(fmt.Sprintf("Error reading logs from buffer: %v", err)) return } _, err = buffer.WriteString(string(line) + "\n") if err != nil { - log.Info(fmt.Sprintf("Error writing bytes to buffer: %v", err)) + consolemsg.Info(fmt.Sprintf("Error writing bytes to buffer: %v", err)) } } diff --git a/pkg/fission-cli/cmd/support/resources/resource.go b/pkg/fission-cli/cmd/support/resources/resource.go index 2754e9dd..0bd36981 100644 --- a/pkg/fission-cli/cmd/support/resources/resource.go +++ b/pkg/fission-cli/cmd/support/resources/resource.go @@ -24,7 +24,7 @@ import ( "github.com/ghodss/yaml" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" "github.com/fission/fission/pkg/utils" ) @@ -45,7 +45,7 @@ func getPodFileName(dumpdir string, pod metav1.ObjectMeta, containerName string) func writeToFile(file string, obj interface{}) { bs, err := yaml.Marshal(obj) if err != nil { - log.Info(fmt.Sprintf("Error encoding object: %v", err)) + consolemsg.Info(fmt.Sprintf("Error encoding object: %v", err)) return } @@ -57,6 +57,6 @@ func writeToFile(file string, obj interface{}) { err = ioutil.WriteFile(file, bs, 0644) if err != nil { - log.Info(fmt.Sprintf("Error writing file %v: %v", file, err)) + consolemsg.Info(fmt.Sprintf("Error writing file %v: %v", file, err)) } } diff --git a/pkg/fission-cli/cmd/timetrigger/create.go b/pkg/fission-cli/cmd/timetrigger/create.go index 76cb6486..cddb9c83 100644 --- a/pkg/fission-cli/cmd/timetrigger/create.go +++ b/pkg/fission-cli/cmd/timetrigger/create.go @@ -28,8 +28,8 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" "github.com/fission/fission/pkg/fission-cli/cmd/spec" + "github.com/fission/fission/pkg/fission-cli/util" ) type CreateSubCommand struct { @@ -38,8 +38,12 @@ type CreateSubCommand struct { } func Create(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := CreateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/timetrigger/delete.go b/pkg/fission-cli/cmd/timetrigger/delete.go index f8d08032..dfba9dec 100644 --- a/pkg/fission-cli/cmd/timetrigger/delete.go +++ b/pkg/fission-cli/cmd/timetrigger/delete.go @@ -23,7 +23,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type DeleteSubCommand struct { @@ -31,14 +31,18 @@ type DeleteSubCommand struct { } func Delete(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := DeleteSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } func (opts *DeleteSubCommand) do(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "triggerns", flags) + m, err := util.GetMetadata("name", "triggerns", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/timetrigger/list.go b/pkg/fission-cli/cmd/timetrigger/list.go index 99f4ca92..567ead2a 100644 --- a/pkg/fission-cli/cmd/timetrigger/list.go +++ b/pkg/fission-cli/cmd/timetrigger/list.go @@ -23,7 +23,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" "github.com/pkg/errors" ) @@ -32,8 +32,12 @@ type ListSubCommand struct { } func List(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ListSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/timetrigger/test.go b/pkg/fission-cli/cmd/timetrigger/test.go index 1e25b4ae..5d00a31e 100644 --- a/pkg/fission-cli/cmd/timetrigger/test.go +++ b/pkg/fission-cli/cmd/timetrigger/test.go @@ -21,7 +21,7 @@ import ( "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type ShowSubCommand struct { @@ -29,8 +29,12 @@ type ShowSubCommand struct { } func Show(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := ShowSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } diff --git a/pkg/fission-cli/cmd/timetrigger/update.go b/pkg/fission-cli/cmd/timetrigger/update.go index 8364f448..18f7a8c1 100644 --- a/pkg/fission-cli/cmd/timetrigger/update.go +++ b/pkg/fission-cli/cmd/timetrigger/update.go @@ -24,7 +24,7 @@ import ( fv1 "github.com/fission/fission/pkg/apis/fission.io/v1" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" + "github.com/fission/fission/pkg/fission-cli/util" ) type UpdateSubCommand struct { @@ -33,8 +33,12 @@ type UpdateSubCommand struct { } func Update(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := UpdateSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -48,7 +52,7 @@ func (opts *UpdateSubCommand) do(flags cli.Input) error { } func (opts *UpdateSubCommand) complete(flags cli.Input) error { - m, err := cmd.GetMetadata("name", "triggerns", flags) + m, err := util.GetMetadata("name", "triggerns", flags) if err != nil { return err } diff --git a/pkg/fission-cli/cmd/util.go b/pkg/fission-cli/cmd/util.go deleted file mode 100644 index b9630553..00000000 --- a/pkg/fission-cli/cmd/util.go +++ /dev/null @@ -1,143 +0,0 @@ -/* -Copyright 2019 The Fission Authors. - -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" - "strconv" - - "github.com/hashicorp/go-multierror" - "github.com/pkg/errors" - "k8s.io/api/core/v1" - "k8s.io/apimachinery/pkg/api/resource" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - "github.com/fission/fission/pkg/controller/client" - "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/util" -) - -func GetServer(flags cli.Input) *client.Client { - return util.GetApiClient(flags.GlobalString(FISSION_SERVER)) -} - -func GetResourceReqs(flags cli.Input, resReqs *v1.ResourceRequirements) (*v1.ResourceRequirements, error) { - r := &v1.ResourceRequirements{} - - if resReqs != nil { - r.Requests = resReqs.Requests - r.Limits = resReqs.Limits - } - - if len(r.Requests) == 0 { - r.Requests = make(map[v1.ResourceName]resource.Quantity) - } - - if len(r.Limits) == 0 { - r.Limits = make(map[v1.ResourceName]resource.Quantity) - } - - e := &multierror.Error{} - - if flags.IsSet(RUNTIME_MINCPU) { - mincpu := flags.Int(RUNTIME_MINCPU) - cpuRequest, err := resource.ParseQuantity(strconv.Itoa(mincpu) + "m") - if err != nil { - e = multierror.Append(e, errors.Wrap(err, "Failed to parse mincpu")) - } - r.Requests[v1.ResourceCPU] = cpuRequest - } - - if flags.IsSet(RUNTIME_MINMEMORY) { - minmem := flags.Int(RUNTIME_MINMEMORY) - memRequest, err := resource.ParseQuantity(strconv.Itoa(minmem) + "Mi") - if err != nil { - e = multierror.Append(e, errors.Wrap(err, "Failed to parse minmemory")) - } - r.Requests[v1.ResourceMemory] = memRequest - } - - if flags.IsSet(RUNTIME_MAXCPU) { - maxcpu := flags.Int(RUNTIME_MAXCPU) - cpuLimit, err := resource.ParseQuantity(strconv.Itoa(maxcpu) + "m") - if err != nil { - e = multierror.Append(e, errors.Wrap(err, "Failed to parse maxcpu")) - } - r.Limits[v1.ResourceCPU] = cpuLimit - } - - if flags.IsSet(RUNTIME_MAXMEMORY) { - maxmem := flags.Int(RUNTIME_MAXMEMORY) - memLimit, err := resource.ParseQuantity(strconv.Itoa(maxmem) + "Mi") - if err != nil { - e = multierror.Append(e, errors.Wrap(err, "Failed to parse maxmemory")) - } - r.Limits[v1.ResourceMemory] = memLimit - } - - limitCPU := r.Limits[v1.ResourceCPU] - requestCPU := r.Requests[v1.ResourceCPU] - - if limitCPU.IsZero() && !requestCPU.IsZero() { - r.Limits[v1.ResourceCPU] = requestCPU - } else if limitCPU.Cmp(requestCPU) < 0 { - e = multierror.Append(e, fmt.Errorf("MinCPU (%v) cannot be greater than MaxCPU (%v)", requestCPU.String(), limitCPU.String())) - } - - limitMem := r.Limits[v1.ResourceMemory] - requestMem := r.Requests[v1.ResourceMemory] - - if limitMem.IsZero() && !requestMem.IsZero() { - r.Limits[v1.ResourceMemory] = requestMem - } else if limitMem.Cmp(requestMem) < 0 { - e = multierror.Append(e, fmt.Errorf("MinMemory (%v) cannot be greater than MaxMemory (%v)", requestMem.String(), limitMem.String())) - } - - if e.ErrorOrNil() != nil { - return nil, e - } - - return &v1.ResourceRequirements{ - Requests: r.Requests, - Limits: r.Limits, - }, nil -} - -func GetSpecDir(flags cli.Input) string { - specDir := flags.String(SPEC_SPECDIR) - if len(specDir) == 0 { - specDir = "specs" - } - return specDir -} - -// GetMetadata returns a pointer to ObjectMeta that is populated with resource name and namespace given by the user. -func GetMetadata(nameFlagText string, namespaceFlagText string, flags cli.Input) (*metav1.ObjectMeta, error) { - name := flags.String(nameFlagText) - if len(name) == 0 { - return nil, errors.Errorf("need a resource name, use --%v", nameFlagText) - } - - ns := flags.String(namespaceFlagText) - - m := &metav1.ObjectMeta{ - Name: name, - Namespace: ns, - } - - return m, nil -} diff --git a/pkg/fission-cli/cmd/version/version.go b/pkg/fission-cli/cmd/version/version.go index ae235bcd..f606dab4 100644 --- a/pkg/fission-cli/cmd/version/version.go +++ b/pkg/fission-cli/cmd/version/version.go @@ -20,11 +20,10 @@ import ( "fmt" "github.com/ghodss/yaml" + "github.com/pkg/errors" "github.com/fission/fission/pkg/controller/client" "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" - "github.com/fission/fission/pkg/fission-cli/cmd" - "github.com/fission/fission/pkg/fission-cli/log" "github.com/fission/fission/pkg/fission-cli/util" ) @@ -33,8 +32,12 @@ type VersionSubCommand struct { } func Version(flags cli.Input) error { + c, err := util.GetServer(flags) + if err != nil { + return err + } opts := &VersionSubCommand{ - client: cmd.GetServer(flags), + client: c, } return opts.do(flags) } @@ -43,7 +46,7 @@ func (opts *VersionSubCommand) do(flags cli.Input) error { ver := util.GetVersion(opts.client) bs, err := yaml.Marshal(ver) if err != nil { - log.Fatal("Error formatting versions: " + err.Error()) + return errors.Wrap(err, "error formatting versions") } fmt.Print(string(bs)) return nil diff --git a/pkg/fission-cli/log/log.go b/pkg/fission-cli/consolemsg/log.go similarity index 91% rename from pkg/fission-cli/log/log.go rename to pkg/fission-cli/consolemsg/log.go index b941d707..a37c4aaa 100644 --- a/pkg/fission-cli/log/log.go +++ b/pkg/fission-cli/consolemsg/log.go @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -package log +package consolemsg import ( "fmt" @@ -27,8 +27,8 @@ var ( ) func Fatal(msg interface{}) { - os.Stderr.WriteString(fmt.Sprintf("Fatal error: %v\n", msg)) - os.Exit(1) + //os.Stderr.WriteString(fmt.Sprintf("Fatal error: %v\n", msg)) + //os.Exit(1) } func Warn(msg interface{}) { diff --git a/pkg/fission-cli/cmd/doc.go b/pkg/fission-cli/flag/const.go similarity index 99% rename from pkg/fission-cli/cmd/doc.go rename to pkg/fission-cli/flag/const.go index cfb5c623..79a2a76b 100644 --- a/pkg/fission-cli/cmd/doc.go +++ b/pkg/fission-cli/flag/const.go @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -package cmd +package flag import "strings" diff --git a/pkg/fission-cli/logdb/influxdb.go b/pkg/fission-cli/logdb/influxdb.go index 156e398b..3fb7fa20 100644 --- a/pkg/fission-cli/logdb/influxdb.go +++ b/pkg/fission-cli/logdb/influxdb.go @@ -30,7 +30,6 @@ import ( "github.com/pkg/errors" ferror "github.com/fission/fission/pkg/error" - "github.com/fission/fission/pkg/fission-cli/log" ) const ( @@ -84,7 +83,7 @@ func (influx InfluxDB) GetLogs(filter LogFilter) ([]LogEntry, error) { logEntries := []LogEntry{} response, err := influx.query(query) if err != nil { - return logEntries, err + return nil, err } for _, r := range response.Results { for _, series := range r.Series { @@ -108,11 +107,11 @@ func (influx InfluxDB) GetLogs(filter LogFilter) ([]LogEntry, error) { for _, row := range series.Values { t, err := time.Parse(time.RFC3339, row[0].(string)) if err != nil { - log.Fatal(err) + return nil, err } seqNum, err := strconv.Atoi(row[seq].(string)) if err != nil { - return logEntries, err + return nil, err } entry := LogEntry{ //The attributes of the LogEntry are selected as relative to their position in InfluxDB's line protocol response diff --git a/pkg/fission-cli/util/portforward.go b/pkg/fission-cli/util/portforward.go index 4eff855a..1cfc4b33 100644 --- a/pkg/fission-cli/util/portforward.go +++ b/pkg/fission-cli/util/portforward.go @@ -25,12 +25,13 @@ import ( "strings" "time" + "github.com/pkg/errors" v1 "k8s.io/api/core/v1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/tools/portforward" "k8s.io/client-go/transport/spdy" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/consolemsg" "github.com/fission/fission/pkg/utils" ) @@ -39,16 +40,16 @@ import ( // is found by looking for a service in the same namespace and using // its targetPort. Once the port forward is started, wait for it to // start accepting connections before returning. -func SetupPortForward(namespace, labelSelector string) string { - log.Verbose(2, "Setting up port forward to %s in namespace %s", +func SetupPortForward(namespace, labelSelector string) (string, error) { + consolemsg.Verbose(2, "Setting up port forward to %s in namespace %s", labelSelector, namespace) localPort, err := findFreePort() if err != nil { - log.Fatal(fmt.Sprintf("Error finding unused port :%v", err.Error())) + return "", errors.Wrap(err, "error finding unused port") } - log.Verbose(2, "Waiting for local port %v", localPort) + consolemsg.Verbose(2, "Waiting for local port %v", localPort) for { conn, _ := net.DialTimeout("tcp", net.JoinHostPort("", localPort), time.Millisecond) @@ -60,15 +61,16 @@ func SetupPortForward(namespace, labelSelector string) string { time.Sleep(time.Millisecond * 50) } - log.Verbose(2, "Starting port forward from local port %v", localPort) + consolemsg.Verbose(2, "Starting port forward from local port %v", localPort) go func() { err := runPortForward(labelSelector, localPort, namespace) if err != nil { - log.Fatal(fmt.Sprintf("Error forwarding to port %v: %s", localPort, err.Error())) + fmt.Printf("Error forwarding to port %v: %s", localPort, err.Error()) + os.Exit(1) } }() - log.Verbose(2, "Waiting for port forward %v to start...", localPort) + consolemsg.Verbose(2, "Waiting for port forward %v to start...", localPort) for { conn, _ := net.DialTimeout("tcp", net.JoinHostPort("", localPort), time.Millisecond) @@ -79,9 +81,9 @@ func SetupPortForward(namespace, labelSelector string) string { time.Sleep(time.Millisecond * 50) } - log.Verbose(2, "Port forward from local port %v started", localPort) + consolemsg.Verbose(2, "Port forward from local port %v started", localPort) - return localPort + return localPort, nil } func findFreePort() (string, error) { @@ -102,9 +104,12 @@ func findFreePort() (string, error) { // runPortForward creates a local port forward to the specified pod func runPortForward(labelSelector string, localPort string, ns string) error { - config, clientset := GetKubernetesClient() + config, clientset, err := GetKubernetesClient() + if err != nil { + return err + } - log.Verbose(2, "Connected to Kubernetes API") + consolemsg.Verbose(2, "Connected to Kubernetes API") // if namespace is unset, try to find a pod in any namespace if len(ns) == 0 { @@ -114,8 +119,10 @@ func runPortForward(labelSelector string, localPort string, ns string) error { // get the pod; if there is more than one, ask the user to disambiguate podList, err := clientset.CoreV1().Pods(ns). List(meta_v1.ListOptions{LabelSelector: labelSelector}) - if err != nil || len(podList.Items) == 0 { - log.Fatal(fmt.Sprintf("Error getting pod for port-forwarding with label selector %v: %v", labelSelector, err)) + if err != nil { + return errors.Wrapf(err, "error getting pod for port-forwarding with label selector %v", labelSelector) + } else if len(podList.Items) == 0 { + return errors.Errorf("no available pod for port-forwarding with label selector %v", labelSelector) } nsList := make([]string, 0) @@ -131,8 +138,8 @@ func runPortForward(labelSelector string, localPort string, ns string) error { namespaces[p.Namespace] = append(namespaces[p.Namespace], &p) } if len(nsList) > 1 { - log.Fatal(fmt.Sprintf("Found %v fission installs, set FISSION_NAMESPACE to one of: %v", - len(namespaces), strings.Join(nsList, " "))) + return errors.Errorf("Found %v fission installs, set FISSION_NAMESPACE to one of: %v", + len(namespaces), strings.Join(nsList, " ")) } } @@ -141,7 +148,7 @@ func runPortForward(labelSelector string, localPort string, ns string) error { ns = nsList[0] pods, ok := namespaces[ns] if !ok { - log.Fatal(fmt.Sprintf("Error finding fission install within the given namespace %v, please check FISSION_NAMESPACE is set properly", ns)) + return errors.Errorf("Error finding fission install within the given namespace %v, please check FISSION_NAMESPACE is set properly", ns) } var podName, podNameSpace string @@ -159,10 +166,10 @@ func runPortForward(labelSelector string, localPort string, ns string) error { svcs, err := clientset.CoreV1().Services(podNameSpace). List(meta_v1.ListOptions{LabelSelector: labelSelector}) if err != nil { - log.Fatal(fmt.Sprintf("Error getting %v service :%v", labelSelector, err.Error())) + return errors.Wrapf(err, "Error getting %v service", labelSelector) } if len(svcs.Items) == 0 { - log.Fatal(fmt.Sprintf("Service %v not found", labelSelector)) + return errors.Errorf("Service %v not found", labelSelector) } service := &svcs.Items[0] @@ -170,7 +177,7 @@ func runPortForward(labelSelector string, localPort string, ns string) error { for _, servicePort := range service.Spec.Ports { targetPort = servicePort.TargetPort.String() } - log.Verbose(2, "Connecting to port %v on pod %v/%v", targetPort, podNameSpace, podNameSpace) + consolemsg.Verbose(2, "Connecting to port %v on pod %v/%v", targetPort, podNameSpace, podNameSpace) stopChannel := make(chan struct{}, 1) readyChannel := make(chan struct{}) @@ -187,21 +194,19 @@ func runPortForward(labelSelector string, localPort string, ns string) error { // actually start the port-forwarding process here transport, upgrader, err := spdy.RoundTripperFor(config) if err != nil { - msg := fmt.Sprintf("Failed to connect to Fission service on Kubernetes: %v", err.Error()) - log.Fatal(msg) + return errors.Errorf("Failed to connect to Fission service on Kubernetes") } dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", url) outStream := os.Stdout - if log.Verbosity < 2 { + if consolemsg.Verbosity < 2 { outStream = nil } fw, err := portforward.New(dialer, ports, stopChannel, readyChannel, outStream, os.Stderr) if err != nil { - msg := fmt.Sprintf("portforward.new errored out :%v", err.Error()) - log.Fatal(msg) + return errors.Wrap(err, "error creating port forwarder") } - log.Verbose(2, "Starting port forwarder") + consolemsg.Verbose(2, "Starting port forwarder") return fw.ForwardPorts() } diff --git a/pkg/fission-cli/util/util.go b/pkg/fission-cli/util/util.go index 5b6d048b..1222d9f3 100644 --- a/pkg/fission-cli/util/util.go +++ b/pkg/fission-cli/util/util.go @@ -22,62 +22,46 @@ import ( "os/user" "path/filepath" "regexp" + "strconv" "strings" + "github.com/hashicorp/go-multierror" + "github.com/pkg/errors" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes" restclient "k8s.io/client-go/rest" "k8s.io/client-go/tools/clientcmd" "github.com/fission/fission/pkg/controller/client" - "github.com/fission/fission/pkg/fission-cli/log" + "github.com/fission/fission/pkg/fission-cli/cliwrapper/cli" + "github.com/fission/fission/pkg/fission-cli/consolemsg" + "github.com/fission/fission/pkg/fission-cli/flag" "github.com/fission/fission/pkg/info" "github.com/fission/fission/pkg/plugin" ) -func GetApiClient(serverUrl string) *client.Client { - if len(serverUrl) == 0 { - // starts local portforwarder etc. - serverUrl = GetServerUrl() - } - - isHTTPS := strings.Index(serverUrl, "https://") == 0 - isHTTP := strings.Index(serverUrl, "http://") == 0 - - if !(isHTTP || isHTTPS) { - serverUrl = "http://" + serverUrl - } - - return client.MakeClient(serverUrl) -} - func GetFissionNamespace() string { fissionNamespace := os.Getenv("FISSION_NAMESPACE") return fissionNamespace } -func GetServerUrl() string { - return GetApplicationUrl("application=fission-api") -} - -func GetApplicationUrl(selector string) string { +func GetApplicationUrl(selector string) (string, error) { var serverUrl string // Use FISSION_URL env variable if set; otherwise, port-forward to controller. fissionUrl := os.Getenv("FISSION_URL") if len(fissionUrl) == 0 { fissionNamespace := GetFissionNamespace() - localPort := SetupPortForward(fissionNamespace, "application=fission-api") + localPort, err := SetupPortForward(fissionNamespace, selector) + if err != nil { + return "", err + } serverUrl = "http://127.0.0.1:" + localPort } else { serverUrl = fissionUrl } - return serverUrl -} - -func CheckErr(err error, msg string) { - if err != nil { - log.Fatal(fmt.Sprintf("Failed to %v: %v", msg, err)) - } + return serverUrl, nil } // KubifyName make a kubernetes compliant name out of an arbitrary string @@ -88,18 +72,15 @@ func KubifyName(old string) string { newName := strings.ToLower(old) // replace disallowed chars with '-' - inv, err := regexp.Compile("[^-a-z0-9]") - CheckErr(err, "compile regexp") + inv, _ := regexp.Compile("[^-a-z0-9]") newName = string(inv.ReplaceAll([]byte(newName), []byte("-"))) // trim leading non-alphabetic - leadingnonalpha, err := regexp.Compile("^[^a-z]+") - CheckErr(err, "compile regexp") + leadingnonalpha, _ := regexp.Compile("^[^a-z]+") newName = string(leadingnonalpha.ReplaceAll([]byte(newName), []byte{})) // trim trailing - trailing, err := regexp.Compile("[^a-z0-9]+$") - CheckErr(err, "compile regexp") + trailing, _ := regexp.Compile("[^a-z0-9]+$") newName = string(trailing.ReplaceAll([]byte(newName), []byte{})) // truncate to length @@ -119,7 +100,7 @@ func KubifyName(old string) string { // GetKubernetesClient builds a new kubernetes client. If the KUBECONFIG // environment variable is empty or doesn't exist, ~/.kube/config is used for // the kube config path -func GetKubernetesClient() (*restclient.Config, *kubernetes.Clientset) { +func GetKubernetesClient() (*restclient.Config, *kubernetes.Clientset, error) { loadingRules := clientcmd.NewDefaultClientConfigLoadingRules() kubeConfigPath := os.Getenv("KUBECONFIG") @@ -130,7 +111,7 @@ func GetKubernetesClient() (*restclient.Config, *kubernetes.Clientset) { // In case that user.Current() may be unable to work under some circumstances and return errors like // "user: Current not implemented on darwin/amd64" due to cross-compilation problem. (https://github.com/golang/go/issues/6376). // Instead of doing fatal here, we fallback to get home directory from the environment $HOME. - log.Warn(fmt.Sprintf("Could not get the current user's directory (%s), fallback to get it from env $HOME", err)) + consolemsg.Warn(fmt.Sprintf("Could not get the current user's directory (%s), fallback to get it from env $HOME", err)) homeDir = os.Getenv("HOME") } else { homeDir = usr.HomeDir @@ -138,27 +119,27 @@ func GetKubernetesClient() (*restclient.Config, *kubernetes.Clientset) { kubeConfigPath = filepath.Join(homeDir, ".kube", "config") if _, err := os.Stat(kubeConfigPath); os.IsNotExist(err) { - log.Fatal("Couldn't find kubeconfig file. " + + return nil, nil, errors.New("Couldn't find kubeconfig file. " + "Set the KUBECONFIG environment variable to your kubeconfig's path.") } loadingRules.ExplicitPath = kubeConfigPath - log.Verbose(2, "Using kubeconfig from %q", kubeConfigPath) + consolemsg.Verbose(2, "Using kubeconfig from %q", kubeConfigPath) } else { - log.Verbose(2, "Using kubeconfig from environment %q", kubeConfigPath) + consolemsg.Verbose(2, "Using kubeconfig from environment %q", kubeConfigPath) } config, err := clientcmd.NewNonInteractiveDeferredLoadingClientConfig( loadingRules, &clientcmd.ConfigOverrides{}).ClientConfig() if err != nil { - log.Fatal(fmt.Sprintf("Failed to build Kubernetes config: %s", err)) + return nil, nil, errors.Wrap(err, "Failed to build Kubernetes config") } clientset, err := kubernetes.NewForConfig(config) if err != nil { - log.Fatal(fmt.Sprintf("Failed to connect to Kubernetes: %s", err)) + return nil, nil, errors.Wrap(err, "Failed to connect to Kubernetes") } - return config, clientset + return config, clientset, nil } // given a list of functions, this checks if the functions actually exist on the cluster @@ -199,7 +180,7 @@ func GetVersion(client *client.Client) info.Versions { serverInfo, err := client.ServerInfo() if err != nil { - log.Warn(fmt.Sprintf("Error getting Fission API version: %v", err)) + consolemsg.Warn(fmt.Sprintf("Error getting Fission API version: %v", err)) serverInfo = &info.ServerInfo{} } @@ -212,3 +193,130 @@ func GetVersion(client *client.Client) info.Versions { return versions } + +func GetServer(flags cli.Input) (c *client.Client, err error) { + serverUrl := flags.GlobalString(flag.FISSION_SERVER) + if len(serverUrl) == 0 { + // starts local portforwarder etc. + serverUrl, err = GetApplicationUrl("application=fission-api") + if err != nil { + return nil, err + } + } + + isHTTPS := strings.Index(serverUrl, "https://") == 0 + isHTTP := strings.Index(serverUrl, "http://") == 0 + + if !(isHTTP || isHTTPS) { + serverUrl = "http://" + serverUrl + } + + return client.MakeClient(serverUrl), nil +} + +func GetResourceReqs(flags cli.Input, resReqs *v1.ResourceRequirements) (*v1.ResourceRequirements, error) { + r := &v1.ResourceRequirements{} + + if resReqs != nil { + r.Requests = resReqs.Requests + r.Limits = resReqs.Limits + } + + if len(r.Requests) == 0 { + r.Requests = make(map[v1.ResourceName]resource.Quantity) + } + + if len(r.Limits) == 0 { + r.Limits = make(map[v1.ResourceName]resource.Quantity) + } + + e := &multierror.Error{} + + if flags.IsSet(flag.RUNTIME_MINCPU) { + mincpu := flags.Int(flag.RUNTIME_MINCPU) + cpuRequest, err := resource.ParseQuantity(strconv.Itoa(mincpu) + "m") + if err != nil { + e = multierror.Append(e, errors.Wrap(err, "Failed to parse mincpu")) + } + r.Requests[v1.ResourceCPU] = cpuRequest + } + + if flags.IsSet(flag.RUNTIME_MINMEMORY) { + minmem := flags.Int(flag.RUNTIME_MINMEMORY) + memRequest, err := resource.ParseQuantity(strconv.Itoa(minmem) + "Mi") + if err != nil { + e = multierror.Append(e, errors.Wrap(err, "Failed to parse minmemory")) + } + r.Requests[v1.ResourceMemory] = memRequest + } + + if flags.IsSet(flag.RUNTIME_MAXCPU) { + maxcpu := flags.Int(flag.RUNTIME_MAXCPU) + cpuLimit, err := resource.ParseQuantity(strconv.Itoa(maxcpu) + "m") + if err != nil { + e = multierror.Append(e, errors.Wrap(err, "Failed to parse maxcpu")) + } + r.Limits[v1.ResourceCPU] = cpuLimit + } + + if flags.IsSet(flag.RUNTIME_MAXMEMORY) { + maxmem := flags.Int(flag.RUNTIME_MAXMEMORY) + memLimit, err := resource.ParseQuantity(strconv.Itoa(maxmem) + "Mi") + if err != nil { + e = multierror.Append(e, errors.Wrap(err, "Failed to parse maxmemory")) + } + r.Limits[v1.ResourceMemory] = memLimit + } + + limitCPU := r.Limits[v1.ResourceCPU] + requestCPU := r.Requests[v1.ResourceCPU] + + if limitCPU.IsZero() && !requestCPU.IsZero() { + r.Limits[v1.ResourceCPU] = requestCPU + } else if limitCPU.Cmp(requestCPU) < 0 { + e = multierror.Append(e, fmt.Errorf("MinCPU (%v) cannot be greater than MaxCPU (%v)", requestCPU.String(), limitCPU.String())) + } + + limitMem := r.Limits[v1.ResourceMemory] + requestMem := r.Requests[v1.ResourceMemory] + + if limitMem.IsZero() && !requestMem.IsZero() { + r.Limits[v1.ResourceMemory] = requestMem + } else if limitMem.Cmp(requestMem) < 0 { + e = multierror.Append(e, fmt.Errorf("MinMemory (%v) cannot be greater than MaxMemory (%v)", requestMem.String(), limitMem.String())) + } + + if e.ErrorOrNil() != nil { + return nil, e + } + + return &v1.ResourceRequirements{ + Requests: r.Requests, + Limits: r.Limits, + }, nil +} + +func GetSpecDir(flags cli.Input) string { + specDir := flags.String(flag.SPEC_SPECDIR) + if len(specDir) == 0 { + specDir = "specs" + } + return specDir +} + +// GetMetadata returns a pointer to ObjectMeta that is populated with resource name and namespace given by the user. +func GetMetadata(nameFlagText string, namespaceFlagText string, flags cli.Input) (*metav1.ObjectMeta, error) { + name := flags.String(nameFlagText) + if len(name) == 0 { + return nil, errors.Errorf("need a resource name, use --%v", nameFlagText) + } + + ns := flags.String(namespaceFlagText) + + m := &metav1.ObjectMeta{ + Name: name, + Namespace: ns, + } + + return m, nil +}