You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openwhisk.apache.org by cs...@apache.org on 2018/01/27 19:55:56 UTC
[incubator-openwhisk-cli] 01/03: Go format source code
This is an automated email from the ASF dual-hosted git repository.
csantanapr pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-openwhisk-cli.git
commit c615efb697af7ef05c9b238005d5c8efe506c323
Author: dubeejw <jw...@us.ibm.com>
AuthorDate: Sat Jan 27 10:16:57 2018 -0500
Go format source code
---
commands/action.go | 1829 ++++++++++++++++++++++----------------------
commands/activation.go | 738 +++++++++---------
commands/api.go | 1671 ++++++++++++++++++++--------------------
commands/commands.go | 370 ++++-----
commands/flags.go | 225 +++---
commands/namespace.go | 180 ++---
commands/package.go | 978 +++++++++++------------
commands/property.go | 998 ++++++++++++------------
commands/qualified_name.go | 204 ++---
commands/rule.go | 754 +++++++++---------
commands/sdk.go | 381 ++++-----
commands/shared.go | 31 +-
commands/trigger.go | 1043 +++++++++++++------------
commands/util.go | 1711 ++++++++++++++++++++---------------------
commands/wsk.go | 70 +-
main.go | 138 ++--
16 files changed, 5668 insertions(+), 5653 deletions(-)
diff --git a/commands/action.go b/commands/action.go
index df75ffd..4d3be58 100644
--- a/commands/action.go
+++ b/commands/action.go
@@ -18,1077 +18,1078 @@
package commands
import (
- "encoding/base64"
- "errors"
- "fmt"
- "path/filepath"
- "io"
- "strings"
- "os"
-
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
-
- "github.com/fatih/color"
- "github.com/spf13/cobra"
- "github.com/mattn/go-colorable"
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
+
+ "github.com/fatih/color"
+ "github.com/mattn/go-colorable"
+ "github.com/spf13/cobra"
)
const (
- MEMORY_LIMIT = 256
- TIMEOUT_LIMIT = 60000
- LOGSIZE_LIMIT = 10
- ACTIVATION_ID = "activationId"
- WEB_EXPORT_ANNOT = "web-export"
- RAW_HTTP_ANNOT = "raw-http"
- FINAL_ANNOT = "final"
- NODE_JS_EXT = ".js"
- PYTHON_EXT = ".py"
- JAVA_EXT = ".jar"
- SWIFT_EXT = ".swift"
- ZIP_EXT = ".zip"
- PHP_EXT = ".php"
- NODE_JS = "nodejs"
- PYTHON = "python"
- JAVA = "java"
- SWIFT = "swift"
- PHP = "php"
- DEFAULT = "default"
- BLACKBOX = "blackbox"
- SEQUENCE = "sequence"
+ MEMORY_LIMIT = 256
+ TIMEOUT_LIMIT = 60000
+ LOGSIZE_LIMIT = 10
+ ACTIVATION_ID = "activationId"
+ WEB_EXPORT_ANNOT = "web-export"
+ RAW_HTTP_ANNOT = "raw-http"
+ FINAL_ANNOT = "final"
+ NODE_JS_EXT = ".js"
+ PYTHON_EXT = ".py"
+ JAVA_EXT = ".jar"
+ SWIFT_EXT = ".swift"
+ ZIP_EXT = ".zip"
+ PHP_EXT = ".php"
+ NODE_JS = "nodejs"
+ PYTHON = "python"
+ JAVA = "java"
+ SWIFT = "swift"
+ PHP = "php"
+ DEFAULT = "default"
+ BLACKBOX = "blackbox"
+ SEQUENCE = "sequence"
)
var actionCmd = &cobra.Command{
- Use: "action",
- Short: wski18n.T("work with actions"),
+ Use: "action",
+ Short: wski18n.T("work with actions"),
}
var actionCreateCmd = &cobra.Command{
- Use: "create ACTION_NAME ACTION",
- Short: wski18n.T("create a new action"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var action *whisk.Action
- var err error
-
- if whiskErr := CheckArgs(
- args,
- 1,
- 2,
- "Action create",
- wski18n.T("An action name and code artifact are required.")); whiskErr != nil {
- return whiskErr
- }
-
- if action, err = parseAction(cmd, args, false); err != nil {
- return actionParseError(cmd, args, err)
- }
-
- if _, _, err = Client.Actions.Insert(action, false); err != nil {
- return actionInsertError(action, err)
- }
-
- printActionCreated(action.Name)
-
- return nil
- },
+ Use: "create ACTION_NAME ACTION",
+ Short: wski18n.T("create a new action"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var action *whisk.Action
+ var err error
+
+ if whiskErr := CheckArgs(
+ args,
+ 1,
+ 2,
+ "Action create",
+ wski18n.T("An action name and code artifact are required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if action, err = parseAction(cmd, args, false); err != nil {
+ return actionParseError(cmd, args, err)
+ }
+
+ if _, _, err = Client.Actions.Insert(action, false); err != nil {
+ return actionInsertError(action, err)
+ }
+
+ printActionCreated(action.Name)
+
+ return nil
+ },
}
var actionUpdateCmd = &cobra.Command{
- Use: "update ACTION_NAME [ACTION]",
- Short: wski18n.T("update an existing action, or create an action if it does not exist"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var action *whisk.Action
- var err error
-
- if whiskErr := CheckArgs(
- args,
- 1,
- 2,
- "Action update",
- wski18n.T("An action name is required. A code artifact is optional.")); whiskErr != nil {
- return whiskErr
- }
-
- if action, err = parseAction(cmd, args, true); err != nil {
- return actionParseError(cmd, args, err)
- }
-
- if _, _, err = Client.Actions.Insert(action, true); err != nil {
- return actionInsertError(action, err)
- }
-
- printActionUpdated(action.Name)
-
- return nil
- },
+ Use: "update ACTION_NAME [ACTION]",
+ Short: wski18n.T("update an existing action, or create an action if it does not exist"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var action *whisk.Action
+ var err error
+
+ if whiskErr := CheckArgs(
+ args,
+ 1,
+ 2,
+ "Action update",
+ wski18n.T("An action name is required. A code artifact is optional.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if action, err = parseAction(cmd, args, true); err != nil {
+ return actionParseError(cmd, args, err)
+ }
+
+ if _, _, err = Client.Actions.Insert(action, true); err != nil {
+ return actionInsertError(action, err)
+ }
+
+ printActionUpdated(action.Name)
+
+ return nil
+ },
}
var actionInvokeCmd = &cobra.Command{
- Use: "invoke ACTION_NAME",
- Short: wski18n.T("invoke action"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var parameters interface{}
- var qualifiedName = new(QualifiedName)
- var paramArgs []string
-
- if whiskErr := CheckArgs(
- args,
- 1,
- 1,
- "Action invoke",
- wski18n.T("An action name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- paramArgs = Flags.common.param
-
- if len(paramArgs) > 0 {
- if parameters, err = getJSONFromStrings(paramArgs, false); err != nil {
- return getJSONFromStringsParamError(paramArgs, false, err)
- }
- }
- if Flags.action.result {
- Flags.common.blocking = true}
-
- res, _, err := Client.Actions.Invoke(
- qualifiedName.GetEntityName(),
- parameters,
- Flags.common.blocking,
- Flags.action.result)
-
- return handleInvocationResponse(*qualifiedName, parameters, res, err)
- },
+ Use: "invoke ACTION_NAME",
+ Short: wski18n.T("invoke action"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var parameters interface{}
+ var qualifiedName = new(QualifiedName)
+ var paramArgs []string
+
+ if whiskErr := CheckArgs(
+ args,
+ 1,
+ 1,
+ "Action invoke",
+ wski18n.T("An action name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ paramArgs = Flags.common.param
+
+ if len(paramArgs) > 0 {
+ if parameters, err = getJSONFromStrings(paramArgs, false); err != nil {
+ return getJSONFromStringsParamError(paramArgs, false, err)
+ }
+ }
+ if Flags.action.result {
+ Flags.common.blocking = true
+ }
+
+ res, _, err := Client.Actions.Invoke(
+ qualifiedName.GetEntityName(),
+ parameters,
+ Flags.common.blocking,
+ Flags.action.result)
+
+ return handleInvocationResponse(*qualifiedName, parameters, res, err)
+ },
}
func handleInvocationResponse(
- qualifiedName QualifiedName,
- parameters interface{},
- result map[string]interface{},
- err error) (error) {
- if err == nil {
- printInvocationMsg(
- qualifiedName.GetNamespace(),
- qualifiedName.GetEntityName(),
- getValueFromJSONResponse(ACTIVATION_ID, result),
- result,
- color.Output)
- } else {
- if !Flags.common.blocking {
- return handleInvocationError(err, qualifiedName.GetEntityName(), parameters)
- } else {
- if isBlockingTimeout(err) {
- printBlockingTimeoutMsg(
- qualifiedName.GetNamespace(),
- qualifiedName.GetEntityName(),
- getValueFromJSONResponse(ACTIVATION_ID, result))
- } else if isApplicationError(err) {
- printInvocationMsg(
- qualifiedName.GetNamespace(),
- qualifiedName.GetEntityName(),
- getValueFromJSONResponse(ACTIVATION_ID, result),
- result,
- colorable.NewColorableStderr())
- } else {
- return handleInvocationError(err, qualifiedName.GetEntityName(), parameters)
- }
- }
- }
-
- return err
+ qualifiedName QualifiedName,
+ parameters interface{},
+ result map[string]interface{},
+ err error) error {
+ if err == nil {
+ printInvocationMsg(
+ qualifiedName.GetNamespace(),
+ qualifiedName.GetEntityName(),
+ getValueFromJSONResponse(ACTIVATION_ID, result),
+ result,
+ color.Output)
+ } else {
+ if !Flags.common.blocking {
+ return handleInvocationError(err, qualifiedName.GetEntityName(), parameters)
+ } else {
+ if isBlockingTimeout(err) {
+ printBlockingTimeoutMsg(
+ qualifiedName.GetNamespace(),
+ qualifiedName.GetEntityName(),
+ getValueFromJSONResponse(ACTIVATION_ID, result))
+ } else if isApplicationError(err) {
+ printInvocationMsg(
+ qualifiedName.GetNamespace(),
+ qualifiedName.GetEntityName(),
+ getValueFromJSONResponse(ACTIVATION_ID, result),
+ result,
+ colorable.NewColorableStderr())
+ } else {
+ return handleInvocationError(err, qualifiedName.GetEntityName(), parameters)
+ }
+ }
+ }
+
+ return err
}
var actionGetCmd = &cobra.Command{
- Use: "get ACTION_NAME [FIELD_FILTER | --summary | --url]",
- Short: wski18n.T("get action"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var field string
- var action *whisk.Action
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 2, "Action get", wski18n.T("An action name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if !Flags.action.url && !Flags.common.summary && len(args) > 1 {
- field = args[1]
-
- if !fieldExists(&whisk.Action{}, field) {
- return invalidFieldFilterError(field)
- }
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- if action, _, err = Client.Actions.Get(qualifiedName.GetEntityName()); err != nil {
- return actionGetError(qualifiedName.GetEntityName(), err)
- }
-
- if Flags.action.url {
- actionURL, err := action.ActionURL(Properties.APIHost,
- DefaultOpenWhiskApiPath,
- Properties.APIVersion,
- qualifiedName.GetPackageName())
- if err != nil {
- errStr := wski18n.T("Invalid host address '{{.host}}': {{.err}}",
- map[string]interface{}{"host": Properties.APIHost, "err": err})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- printActionGetWithURL(qualifiedName.GetEntity(), actionURL)
- } else if Flags.common.summary {
- printSummary(action)
- } else if cmd.LocalFlags().Changed(SAVE_AS_FLAG) || cmd.LocalFlags().Changed(SAVE_FLAG) {
- return saveCode(*action, Flags.action.saveAs)
- } else {
- if len(field) > 0 {
- printActionGetWithField(qualifiedName.GetEntityName(), field, action)
- } else {
- printActionGet(qualifiedName.GetEntityName(), action)
- }
- }
-
- return nil
- },
+ Use: "get ACTION_NAME [FIELD_FILTER | --summary | --url]",
+ Short: wski18n.T("get action"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var field string
+ var action *whisk.Action
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 2, "Action get", wski18n.T("An action name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if !Flags.action.url && !Flags.common.summary && len(args) > 1 {
+ field = args[1]
+
+ if !fieldExists(&whisk.Action{}, field) {
+ return invalidFieldFilterError(field)
+ }
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ if action, _, err = Client.Actions.Get(qualifiedName.GetEntityName()); err != nil {
+ return actionGetError(qualifiedName.GetEntityName(), err)
+ }
+
+ if Flags.action.url {
+ actionURL, err := action.ActionURL(Properties.APIHost,
+ DefaultOpenWhiskApiPath,
+ Properties.APIVersion,
+ qualifiedName.GetPackageName())
+ if err != nil {
+ errStr := wski18n.T("Invalid host address '{{.host}}': {{.err}}",
+ map[string]interface{}{"host": Properties.APIHost, "err": err})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ printActionGetWithURL(qualifiedName.GetEntity(), actionURL)
+ } else if Flags.common.summary {
+ printSummary(action)
+ } else if cmd.LocalFlags().Changed(SAVE_AS_FLAG) || cmd.LocalFlags().Changed(SAVE_FLAG) {
+ return saveCode(*action, Flags.action.saveAs)
+ } else {
+ if len(field) > 0 {
+ printActionGetWithField(qualifiedName.GetEntityName(), field, action)
+ } else {
+ printActionGet(qualifiedName.GetEntityName(), action)
+ }
+ }
+
+ return nil
+ },
}
var actionDeleteCmd = &cobra.Command{
- Use: "delete ACTION_NAME",
- Short: wski18n.T("delete action"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var qualifiedName = new(QualifiedName)
- var err error
-
- if whiskErr := CheckArgs(
- args,
- 1,
- 1,
- "Action delete",
- wski18n.T("An action name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- if _, err = Client.Actions.Delete(qualifiedName.GetEntityName()); err != nil {
- return actionDeleteError(qualifiedName.GetEntityName(), err)
- }
-
- printActionDeleted(qualifiedName.GetEntityName())
-
- return nil
- },
+ Use: "delete ACTION_NAME",
+ Short: wski18n.T("delete action"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var qualifiedName = new(QualifiedName)
+ var err error
+
+ if whiskErr := CheckArgs(
+ args,
+ 1,
+ 1,
+ "Action delete",
+ wski18n.T("An action name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ if _, err = Client.Actions.Delete(qualifiedName.GetEntityName()); err != nil {
+ return actionDeleteError(qualifiedName.GetEntityName(), err)
+ }
+
+ printActionDeleted(qualifiedName.GetEntityName())
+
+ return nil
+ },
}
var actionListCmd = &cobra.Command{
- Use: "list [ NAMESPACE | PACKAGE_NAME ]",
- Short: wski18n.T("list all actions in a namespace or actions contained in a package"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var qualifiedName = new(QualifiedName)
- var actions []whisk.Action
- var err error
-
- if whiskErr := CheckArgs(
- args,
- 0,
- 1,
- "Action list",
- wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
- return whiskErr
- }
-
- if len(args) == 1 {
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- }
-
- options := &whisk.ActionListOptions{
- Skip: Flags.common.skip,
- Limit: Flags.common.limit,
- }
-
- if actions, _, err = Client.Actions.List(qualifiedName.GetEntityName(), options); err != nil {
- return actionListError(qualifiedName.GetEntityName(), options, err)
- }
-
- sortByName := Flags.common.nameSort
- printList(actions, sortByName)
-
- return nil
- },
+ Use: "list [ NAMESPACE | PACKAGE_NAME ]",
+ Short: wski18n.T("list all actions in a namespace or actions contained in a package"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var qualifiedName = new(QualifiedName)
+ var actions []whisk.Action
+ var err error
+
+ if whiskErr := CheckArgs(
+ args,
+ 0,
+ 1,
+ "Action list",
+ wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if len(args) == 1 {
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ }
+
+ options := &whisk.ActionListOptions{
+ Skip: Flags.common.skip,
+ Limit: Flags.common.limit,
+ }
+
+ if actions, _, err = Client.Actions.List(qualifiedName.GetEntityName(), options); err != nil {
+ return actionListError(qualifiedName.GetEntityName(), options, err)
+ }
+
+ sortByName := Flags.common.nameSort
+ printList(actions, sortByName)
+
+ return nil
+ },
}
func parseAction(cmd *cobra.Command, args []string, update bool) (*whisk.Action, error) {
- var err error
- var existingAction *whisk.Action
- var paramArgs []string
- var annotArgs []string
- var parameters interface{}
- var annotations interface{}
-
- var qualifiedName = new(QualifiedName)
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return nil, NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- action := new(whisk.Action)
- action.Name = qualifiedName.GetEntityName()
- action.Namespace = qualifiedName.GetNamespace()
- action.Limits = getLimits(
- cmd.LocalFlags().Changed(MEMORY_FLAG),
- cmd.LocalFlags().Changed(LOG_SIZE_FLAG),
- cmd.LocalFlags().Changed(TIMEOUT_FLAG),
- Flags.action.memory,
- Flags.action.logsize,
- Flags.action.timeout)
-
- paramArgs = Flags.common.param
- annotArgs = Flags.common.annotation
-
- if len(paramArgs) > 0 {
- if parameters, err = getJSONFromStrings(paramArgs, true); err != nil {
- return nil, getJSONFromStringsParamError(paramArgs, true, err)
- }
-
- action.Parameters = parameters.(whisk.KeyValueArr)
- }
-
- if len(annotArgs) > 0 {
- if annotations, err = getJSONFromStrings(annotArgs, true); err != nil {
- return nil, getJSONFromStringsAnnotError(annotArgs, true, err)
- }
-
- action.Annotations = annotations.(whisk.KeyValueArr)
- }
-
- if len(Flags.action.kind) > 0 && len(Flags.action.docker) > 0 {
- errStr := wski18n.T("Cannot specify both --kind and --docker at the same time.")
- return nil, whisk.MakeWskError(errors.New(errStr), whisk.NOT_ALLOWED, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- }
-
- if Flags.action.copy {
- var copiedQualifiedName = new(QualifiedName)
-
- if copiedQualifiedName, err = NewQualifiedName(args[1]); err != nil {
- return nil, NewQualifiedNameError(args[1], err)
- }
-
- Client.Namespace = copiedQualifiedName.GetNamespace()
-
- if existingAction, _, err = Client.Actions.Get(copiedQualifiedName.GetEntityName()); err != nil {
- return nil, actionGetError(copiedQualifiedName.GetEntityName(), err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- action.Exec = existingAction.Exec
- action.Parameters = append(action.Parameters, existingAction.Parameters...)
- action.Annotations = append(action.Annotations, existingAction.Annotations...)
- } else if Flags.action.sequence {
- if len(args) == 2 {
- action.Exec = new(whisk.Exec)
- action.Exec.Kind = SEQUENCE
- action.Exec.Components = csvToQualifiedActions(args[1])
- } else {
- return nil, noArtifactError()
- }
- } else if len(args) > 1 || len(Flags.action.docker) > 0 {
- action.Exec, err = getExec(args, Flags.action)
- if err != nil {
- return nil, err
- }
- } else if !update {
- return nil, noArtifactError()
- }
-
- if cmd.LocalFlags().Changed(WEB_FLAG) {
- preserveAnnotations := action.Annotations == nil
- action.Annotations, err = webAction(Flags.action.web, action.Annotations, qualifiedName.GetEntityName(), preserveAnnotations)
- }
-
- whisk.Debug(whisk.DbgInfo, "Parsed action struct: %#v\n", action)
-
- return action, err
+ var err error
+ var existingAction *whisk.Action
+ var paramArgs []string
+ var annotArgs []string
+ var parameters interface{}
+ var annotations interface{}
+
+ var qualifiedName = new(QualifiedName)
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return nil, NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ action := new(whisk.Action)
+ action.Name = qualifiedName.GetEntityName()
+ action.Namespace = qualifiedName.GetNamespace()
+ action.Limits = getLimits(
+ cmd.LocalFlags().Changed(MEMORY_FLAG),
+ cmd.LocalFlags().Changed(LOG_SIZE_FLAG),
+ cmd.LocalFlags().Changed(TIMEOUT_FLAG),
+ Flags.action.memory,
+ Flags.action.logsize,
+ Flags.action.timeout)
+
+ paramArgs = Flags.common.param
+ annotArgs = Flags.common.annotation
+
+ if len(paramArgs) > 0 {
+ if parameters, err = getJSONFromStrings(paramArgs, true); err != nil {
+ return nil, getJSONFromStringsParamError(paramArgs, true, err)
+ }
+
+ action.Parameters = parameters.(whisk.KeyValueArr)
+ }
+
+ if len(annotArgs) > 0 {
+ if annotations, err = getJSONFromStrings(annotArgs, true); err != nil {
+ return nil, getJSONFromStringsAnnotError(annotArgs, true, err)
+ }
+
+ action.Annotations = annotations.(whisk.KeyValueArr)
+ }
+
+ if len(Flags.action.kind) > 0 && len(Flags.action.docker) > 0 {
+ errStr := wski18n.T("Cannot specify both --kind and --docker at the same time.")
+ return nil, whisk.MakeWskError(errors.New(errStr), whisk.NOT_ALLOWED, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ }
+
+ if Flags.action.copy {
+ var copiedQualifiedName = new(QualifiedName)
+
+ if copiedQualifiedName, err = NewQualifiedName(args[1]); err != nil {
+ return nil, NewQualifiedNameError(args[1], err)
+ }
+
+ Client.Namespace = copiedQualifiedName.GetNamespace()
+
+ if existingAction, _, err = Client.Actions.Get(copiedQualifiedName.GetEntityName()); err != nil {
+ return nil, actionGetError(copiedQualifiedName.GetEntityName(), err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ action.Exec = existingAction.Exec
+ action.Parameters = append(action.Parameters, existingAction.Parameters...)
+ action.Annotations = append(action.Annotations, existingAction.Annotations...)
+ } else if Flags.action.sequence {
+ if len(args) == 2 {
+ action.Exec = new(whisk.Exec)
+ action.Exec.Kind = SEQUENCE
+ action.Exec.Components = csvToQualifiedActions(args[1])
+ } else {
+ return nil, noArtifactError()
+ }
+ } else if len(args) > 1 || len(Flags.action.docker) > 0 {
+ action.Exec, err = getExec(args, Flags.action)
+ if err != nil {
+ return nil, err
+ }
+ } else if !update {
+ return nil, noArtifactError()
+ }
+
+ if cmd.LocalFlags().Changed(WEB_FLAG) {
+ preserveAnnotations := action.Annotations == nil
+ action.Annotations, err = webAction(Flags.action.web, action.Annotations, qualifiedName.GetEntityName(), preserveAnnotations)
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Parsed action struct: %#v\n", action)
+
+ return action, err
}
func getExec(args []string, params ActionFlags) (*whisk.Exec, error) {
- var err error
- var code string
- var exec *whisk.Exec
-
- exec = new(whisk.Exec)
- kind := params.kind
- isNative := params.native
- docker := params.docker
- mainEntry := params.main
- ext := ""
-
- if len(args) == 2 {
- artifact := args[1]
- ext = filepath.Ext(artifact)
- code, err = ReadFile(artifact)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "ReadFile(%s) error: %s\n", artifact, err)
- return nil, err
- }
-
- if ext == ZIP_EXT || ext == JAVA_EXT {
- code = base64.StdEncoding.EncodeToString([]byte(code))
- }
-
- exec.Code = &code
- } else if len(args) == 1 && len(docker) == 0 {
- return nil, noArtifactError()
- } else if len(args) > 1 {
- return nil, noArtifactError()
- }
-
- if len(kind) > 0 {
- exec.Kind = kind
- } else if len(docker) > 0 || isNative {
- exec.Kind = BLACKBOX
- if isNative {
- exec.Image = "openwhisk/dockerskeleton"
- } else {
- exec.Image = docker
- }
- } else if ext == SWIFT_EXT {
- exec.Kind = fmt.Sprintf("%s:%s", SWIFT, DEFAULT)
- } else if ext == NODE_JS_EXT {
- exec.Kind = fmt.Sprintf("%s:%s", NODE_JS, DEFAULT)
- } else if ext == PYTHON_EXT {
- exec.Kind = fmt.Sprintf("%s:%s", PYTHON, DEFAULT)
- } else if ext == JAVA_EXT {
- exec.Kind = fmt.Sprintf("%s:%s", JAVA, DEFAULT)
- } else if ext == PHP_EXT {
- exec.Kind = fmt.Sprintf("%s:%s", PHP, DEFAULT)
- } else {
- if ext == ZIP_EXT {
- return nil, zipKindError()
- } else {
- return nil, extensionError(ext)
- }
- }
-
- // Error if entry point is not specified for Java
- if len(mainEntry) != 0 {
- exec.Main = mainEntry
- } else {
- if exec.Kind == "java" {
- return nil, javaEntryError()
- }
- }
-
- return exec, nil
+ var err error
+ var code string
+ var exec *whisk.Exec
+
+ exec = new(whisk.Exec)
+ kind := params.kind
+ isNative := params.native
+ docker := params.docker
+ mainEntry := params.main
+ ext := ""
+
+ if len(args) == 2 {
+ artifact := args[1]
+ ext = filepath.Ext(artifact)
+ code, err = ReadFile(artifact)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "ReadFile(%s) error: %s\n", artifact, err)
+ return nil, err
+ }
+
+ if ext == ZIP_EXT || ext == JAVA_EXT {
+ code = base64.StdEncoding.EncodeToString([]byte(code))
+ }
+
+ exec.Code = &code
+ } else if len(args) == 1 && len(docker) == 0 {
+ return nil, noArtifactError()
+ } else if len(args) > 1 {
+ return nil, noArtifactError()
+ }
+
+ if len(kind) > 0 {
+ exec.Kind = kind
+ } else if len(docker) > 0 || isNative {
+ exec.Kind = BLACKBOX
+ if isNative {
+ exec.Image = "openwhisk/dockerskeleton"
+ } else {
+ exec.Image = docker
+ }
+ } else if ext == SWIFT_EXT {
+ exec.Kind = fmt.Sprintf("%s:%s", SWIFT, DEFAULT)
+ } else if ext == NODE_JS_EXT {
+ exec.Kind = fmt.Sprintf("%s:%s", NODE_JS, DEFAULT)
+ } else if ext == PYTHON_EXT {
+ exec.Kind = fmt.Sprintf("%s:%s", PYTHON, DEFAULT)
+ } else if ext == JAVA_EXT {
+ exec.Kind = fmt.Sprintf("%s:%s", JAVA, DEFAULT)
+ } else if ext == PHP_EXT {
+ exec.Kind = fmt.Sprintf("%s:%s", PHP, DEFAULT)
+ } else {
+ if ext == ZIP_EXT {
+ return nil, zipKindError()
+ } else {
+ return nil, extensionError(ext)
+ }
+ }
+
+ // Error if entry point is not specified for Java
+ if len(mainEntry) != 0 {
+ exec.Main = mainEntry
+ } else {
+ if exec.Kind == "java" {
+ return nil, javaEntryError()
+ }
+ }
+
+ return exec, nil
}
func getBinaryKindExtension(runtime string) (extension string) {
- switch strings.ToLower(runtime) {
- case JAVA:
- extension = JAVA_EXT
- default:
- extension = ZIP_EXT
- }
-
- return extension
+ switch strings.ToLower(runtime) {
+ case JAVA:
+ extension = JAVA_EXT
+ default:
+ extension = ZIP_EXT
+ }
+
+ return extension
}
func getKindExtension(runtime string) (extension string) {
- switch strings.ToLower(runtime) {
- case NODE_JS:
- extension = NODE_JS_EXT
- case PYTHON:
- extension = PYTHON_EXT
- case SWIFT:
- fallthrough
- case PHP:
- extension = fmt.Sprintf(".%s", runtime)
- }
-
- return extension
+ switch strings.ToLower(runtime) {
+ case NODE_JS:
+ extension = NODE_JS_EXT
+ case PYTHON:
+ extension = PYTHON_EXT
+ case SWIFT:
+ fallthrough
+ case PHP:
+ extension = fmt.Sprintf(".%s", runtime)
+ }
+
+ return extension
}
func saveCode(action whisk.Action, filename string) (err error) {
- var code string
- var runtime string
- var exec whisk.Exec
-
- exec = *action.Exec
- runtime = strings.Split(exec.Kind, ":")[0]
-
- if strings.ToLower(runtime) == BLACKBOX {
- return cannotSaveImageError()
- } else if strings.ToLower(runtime) == SEQUENCE {
- return cannotSaveSequenceError()
- }
-
- if exec.Code != nil {
- code = *exec.Code
- }
-
- if *exec.Binary {
- decoded, _ := base64.StdEncoding.DecodeString(code)
- code = string(decoded)
-
- if len(filename) == 0 {
- filename = action.Name + getBinaryKindExtension(runtime)
- }
- } else {
- if len(filename) == 0 {
- filename = action.Name + getKindExtension(runtime)
- }
- }
-
- if exists, err := FileExists(filename); err != nil {
- return err
- } else if exists {
- return fileExistsError(filename)
- }
-
- if err := writeFile(filename, code); err != nil {
- return err
- }
-
- pwd, err := os.Getwd()
- if err != nil {
- whisk.Debug(whisk.DbgError, "os.Getwd() error: %s\n", err)
- return err
- }
-
- savedPath := fmt.Sprintf("%s%s%s", pwd, string(os.PathSeparator), filename)
-
- printSavedActionCodeSuccess(savedPath)
-
- return nil
+ var code string
+ var runtime string
+ var exec whisk.Exec
+
+ exec = *action.Exec
+ runtime = strings.Split(exec.Kind, ":")[0]
+
+ if strings.ToLower(runtime) == BLACKBOX {
+ return cannotSaveImageError()
+ } else if strings.ToLower(runtime) == SEQUENCE {
+ return cannotSaveSequenceError()
+ }
+
+ if exec.Code != nil {
+ code = *exec.Code
+ }
+
+ if *exec.Binary {
+ decoded, _ := base64.StdEncoding.DecodeString(code)
+ code = string(decoded)
+
+ if len(filename) == 0 {
+ filename = action.Name + getBinaryKindExtension(runtime)
+ }
+ } else {
+ if len(filename) == 0 {
+ filename = action.Name + getKindExtension(runtime)
+ }
+ }
+
+ if exists, err := FileExists(filename); err != nil {
+ return err
+ } else if exists {
+ return fileExistsError(filename)
+ }
+
+ if err := writeFile(filename, code); err != nil {
+ return err
+ }
+
+ pwd, err := os.Getwd()
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "os.Getwd() error: %s\n", err)
+ return err
+ }
+
+ savedPath := fmt.Sprintf("%s%s%s", pwd, string(os.PathSeparator), filename)
+
+ printSavedActionCodeSuccess(savedPath)
+
+ return nil
}
-func webAction(webMode string, annotations whisk.KeyValueArr, entityName string, preserveAnnotations bool) (whisk.KeyValueArr, error){
- switch strings.ToLower(webMode) {
- case "yes":
- fallthrough
- case "true":
- return webActionAnnotations(preserveAnnotations, annotations, entityName, addWebAnnotations)
- case "no":
- fallthrough
- case "false":
- return webActionAnnotations(preserveAnnotations, annotations, entityName, deleteWebAnnotations)
- case "raw":
- return webActionAnnotations(preserveAnnotations, annotations, entityName, addRawAnnotations)
- default:
- return nil, webInputError(webMode)
- }
+func webAction(webMode string, annotations whisk.KeyValueArr, entityName string, preserveAnnotations bool) (whisk.KeyValueArr, error) {
+ switch strings.ToLower(webMode) {
+ case "yes":
+ fallthrough
+ case "true":
+ return webActionAnnotations(preserveAnnotations, annotations, entityName, addWebAnnotations)
+ case "no":
+ fallthrough
+ case "false":
+ return webActionAnnotations(preserveAnnotations, annotations, entityName, deleteWebAnnotations)
+ case "raw":
+ return webActionAnnotations(preserveAnnotations, annotations, entityName, addRawAnnotations)
+ default:
+ return nil, webInputError(webMode)
+ }
}
-type WebActionAnnotationMethod func(annotations whisk.KeyValueArr) (whisk.KeyValueArr)
+type WebActionAnnotationMethod func(annotations whisk.KeyValueArr) whisk.KeyValueArr
func webActionAnnotations(
- preserveAnnotations bool,
- annotations whisk.KeyValueArr,
- entityName string,
- webActionAnnotationMethod WebActionAnnotationMethod) (whisk.KeyValueArr, error) {
- var action *whisk.Action
- var err error
-
- if preserveAnnotations {
- if action, _, err = Client.Actions.Get(entityName); err != nil {
- whiskErr, isWhiskError := err.(*whisk.WskError)
-
- if (isWhiskError && whiskErr.ExitCode != whisk.EXIT_CODE_NOT_FOUND) || !isWhiskError {
- return nil, actionGetError(entityName, err)
- }
- } else {
- annotations = whisk.KeyValueArr.AppendKeyValueArr(annotations, action.Annotations)
- }
- }
-
- annotations = webActionAnnotationMethod(annotations)
-
- return annotations, nil
+ preserveAnnotations bool,
+ annotations whisk.KeyValueArr,
+ entityName string,
+ webActionAnnotationMethod WebActionAnnotationMethod) (whisk.KeyValueArr, error) {
+ var action *whisk.Action
+ var err error
+
+ if preserveAnnotations {
+ if action, _, err = Client.Actions.Get(entityName); err != nil {
+ whiskErr, isWhiskError := err.(*whisk.WskError)
+
+ if (isWhiskError && whiskErr.ExitCode != whisk.EXIT_CODE_NOT_FOUND) || !isWhiskError {
+ return nil, actionGetError(entityName, err)
+ }
+ } else {
+ annotations = whisk.KeyValueArr.AppendKeyValueArr(annotations, action.Annotations)
+ }
+ }
+
+ annotations = webActionAnnotationMethod(annotations)
+
+ return annotations, nil
}
-func addWebAnnotations(annotations whisk.KeyValueArr) (whisk.KeyValueArr) {
- annotations = deleteWebAnnotationKeys(annotations)
- annotations = addKeyValue(WEB_EXPORT_ANNOT, true, annotations)
- annotations = addKeyValue(RAW_HTTP_ANNOT, false, annotations)
- annotations = addKeyValue(FINAL_ANNOT, true, annotations)
+func addWebAnnotations(annotations whisk.KeyValueArr) whisk.KeyValueArr {
+ annotations = deleteWebAnnotationKeys(annotations)
+ annotations = addKeyValue(WEB_EXPORT_ANNOT, true, annotations)
+ annotations = addKeyValue(RAW_HTTP_ANNOT, false, annotations)
+ annotations = addKeyValue(FINAL_ANNOT, true, annotations)
- return annotations
+ return annotations
}
-func deleteWebAnnotations(annotations whisk.KeyValueArr) (whisk.KeyValueArr) {
- annotations = deleteWebAnnotationKeys(annotations)
- annotations = addKeyValue(WEB_EXPORT_ANNOT, false, annotations)
- annotations = addKeyValue(RAW_HTTP_ANNOT, false, annotations)
- annotations = addKeyValue(FINAL_ANNOT, false, annotations)
+func deleteWebAnnotations(annotations whisk.KeyValueArr) whisk.KeyValueArr {
+ annotations = deleteWebAnnotationKeys(annotations)
+ annotations = addKeyValue(WEB_EXPORT_ANNOT, false, annotations)
+ annotations = addKeyValue(RAW_HTTP_ANNOT, false, annotations)
+ annotations = addKeyValue(FINAL_ANNOT, false, annotations)
- return annotations
+ return annotations
}
-func addRawAnnotations(annotations whisk.KeyValueArr) (whisk.KeyValueArr) {
- annotations = deleteWebAnnotationKeys(annotations)
- annotations = addKeyValue(WEB_EXPORT_ANNOT, true, annotations)
- annotations = addKeyValue(RAW_HTTP_ANNOT, true, annotations)
- annotations = addKeyValue(FINAL_ANNOT, true, annotations)
+func addRawAnnotations(annotations whisk.KeyValueArr) whisk.KeyValueArr {
+ annotations = deleteWebAnnotationKeys(annotations)
+ annotations = addKeyValue(WEB_EXPORT_ANNOT, true, annotations)
+ annotations = addKeyValue(RAW_HTTP_ANNOT, true, annotations)
+ annotations = addKeyValue(FINAL_ANNOT, true, annotations)
- return annotations
+ return annotations
}
-func deleteWebAnnotationKeys(annotations whisk.KeyValueArr) (whisk.KeyValueArr) {
- annotations = deleteKey(WEB_EXPORT_ANNOT, annotations)
- annotations = deleteKey(RAW_HTTP_ANNOT, annotations)
- annotations = deleteKey(FINAL_ANNOT, annotations)
+func deleteWebAnnotationKeys(annotations whisk.KeyValueArr) whisk.KeyValueArr {
+ annotations = deleteKey(WEB_EXPORT_ANNOT, annotations)
+ annotations = deleteKey(RAW_HTTP_ANNOT, annotations)
+ annotations = deleteKey(FINAL_ANNOT, annotations)
- return annotations
+ return annotations
}
-func getLimits(memorySet bool, logSizeSet bool, timeoutSet bool, memory int, logSize int, timeout int) (*whisk.Limits) {
- var limits *whisk.Limits
+func getLimits(memorySet bool, logSizeSet bool, timeoutSet bool, memory int, logSize int, timeout int) *whisk.Limits {
+ var limits *whisk.Limits
- if memorySet || logSizeSet || timeoutSet {
- limits = new(whisk.Limits)
+ if memorySet || logSizeSet || timeoutSet {
+ limits = new(whisk.Limits)
- if memorySet {
- limits.Memory = &memory
- }
+ if memorySet {
+ limits.Memory = &memory
+ }
- if logSizeSet {
- limits.Logsize = &logSize
- }
+ if logSizeSet {
+ limits.Logsize = &logSize
+ }
- if timeoutSet {
- limits.Timeout = &timeout
- }
- }
+ if timeoutSet {
+ limits.Timeout = &timeout
+ }
+ }
- return limits
+ return limits
}
-func nestedError(errorMessage string, err error) (error) {
- return whisk.MakeWskErrorFromWskError(
- errors.New(errorMessage),
- err,
- whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG,
- whisk.DISPLAY_USAGE)
+func nestedError(errorMessage string, err error) error {
+ return whisk.MakeWskErrorFromWskError(
+ errors.New(errorMessage),
+ err,
+ whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG,
+ whisk.DISPLAY_USAGE)
}
-func nonNestedError(errorMessage string) (error) {
- return whisk.MakeWskError(
- errors.New(errorMessage),
- whisk.EXIT_CODE_ERR_USAGE,
- whisk.DISPLAY_MSG,
- whisk.DISPLAY_USAGE)
+func nonNestedError(errorMessage string) error {
+ return whisk.MakeWskError(
+ errors.New(errorMessage),
+ whisk.EXIT_CODE_ERR_USAGE,
+ whisk.DISPLAY_MSG,
+ whisk.DISPLAY_USAGE)
}
-func actionParseError(cmd *cobra.Command, args []string, err error) (error) {
- whisk.Debug(whisk.DbgError, "parseAction(%s, %s) error: %s\n", cmd, args, err)
+func actionParseError(cmd *cobra.Command, args []string, err error) error {
+ whisk.Debug(whisk.DbgError, "parseAction(%s, %s) error: %s\n", cmd, args, err)
- errMsg := wski18n.T(
- "Invalid argument(s). {{.required}}",
- map[string]interface{}{
- "required": err,
- })
+ errMsg := wski18n.T(
+ "Invalid argument(s). {{.required}}",
+ map[string]interface{}{
+ "required": err,
+ })
- return nestedError(errMsg, err)
+ return nestedError(errMsg, err)
}
-func actionInsertError(action *whisk.Action, err error) (error) {
- whisk.Debug(whisk.DbgError, "Client.Actions.Insert(%#v, false) error: %s\n", action, err)
+func actionInsertError(action *whisk.Action, err error) error {
+ whisk.Debug(whisk.DbgError, "Client.Actions.Insert(%#v, false) error: %s\n", action, err)
- errMsg := wski18n.T(
- "Unable to create action '{{.name}}': {{.err}}",
- map[string]interface{}{
- "name": action.Name,
- "err": err,
- })
+ errMsg := wski18n.T(
+ "Unable to create action '{{.name}}': {{.err}}",
+ map[string]interface{}{
+ "name": action.Name,
+ "err": err,
+ })
- return nestedError(errMsg, err)
+ return nestedError(errMsg, err)
}
-func getJSONFromStringsParamError(params []string, keyValueFormat bool, err error) (error) {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, %t) failed: %s\n", params, keyValueFormat, err)
+func getJSONFromStringsParamError(params []string, keyValueFormat bool, err error) error {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, %t) failed: %s\n", params, keyValueFormat, err)
- errMsg := wski18n.T(
- "Invalid parameter argument '{{.param}}': {{.err}}",
- map[string]interface{}{
- "param": fmt.Sprintf("%#v", params),
- "err": err,
- })
+ errMsg := wski18n.T(
+ "Invalid parameter argument '{{.param}}': {{.err}}",
+ map[string]interface{}{
+ "param": fmt.Sprintf("%#v", params),
+ "err": err,
+ })
- return nestedError(errMsg, err)
+ return nestedError(errMsg, err)
}
-func getJSONFromStringsAnnotError(annots []string, keyValueFormat bool, err error) (error) {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, %t) failed: %s\n", annots, keyValueFormat, err)
+func getJSONFromStringsAnnotError(annots []string, keyValueFormat bool, err error) error {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, %t) failed: %s\n", annots, keyValueFormat, err)
- errMsg := wski18n.T(
- "Invalid annotation argument '{{.annotation}}': {{.err}}",
- map[string]interface{}{
- "annotation": fmt.Sprintf("%#v", annots),
- "err": err,
- })
+ errMsg := wski18n.T(
+ "Invalid annotation argument '{{.annotation}}': {{.err}}",
+ map[string]interface{}{
+ "annotation": fmt.Sprintf("%#v", annots),
+ "err": err,
+ })
- return nestedError(errMsg, err)
+ return nestedError(errMsg, err)
}
-func invalidFieldFilterError(field string) (error) {
- errMsg := wski18n.T(
- "Invalid field filter '{{.arg}}'.",
- map[string]interface{}{
- "arg": field,
- })
+func invalidFieldFilterError(field string) error {
+ errMsg := wski18n.T(
+ "Invalid field filter '{{.arg}}'.",
+ map[string]interface{}{
+ "arg": field,
+ })
- return nonNestedError(errMsg)
+ return nonNestedError(errMsg)
}
-func actionDeleteError(entityName string, err error) (error) {
- whisk.Debug(whisk.DbgError, "Client.Actions.Delete(%s) error: %s\n", entityName, err)
+func actionDeleteError(entityName string, err error) error {
+ whisk.Debug(whisk.DbgError, "Client.Actions.Delete(%s) error: %s\n", entityName, err)
- errMsg := wski18n.T(
- "Unable to delete action '{{.name}}': {{.err}}",
- map[string]interface{}{
- "name": entityName,
- "err": err,
- })
+ errMsg := wski18n.T(
+ "Unable to delete action '{{.name}}': {{.err}}",
+ map[string]interface{}{
+ "name": entityName,
+ "err": err,
+ })
- return nestedError(errMsg, err)
+ return nestedError(errMsg, err)
}
-func actionGetError(entityName string, err error) (error) {
- whisk.Debug(whisk.DbgError, "Client.Actions.Get(%s) error: %s\n", entityName, err)
+func actionGetError(entityName string, err error) error {
+ whisk.Debug(whisk.DbgError, "Client.Actions.Get(%s) error: %s\n", entityName, err)
- errMsg := wski18n.T(
- "Unable to get action '{{.name}}': {{.err}}",
- map[string]interface{}{
- "name": entityName,
- "err": err,
- })
+ errMsg := wski18n.T(
+ "Unable to get action '{{.name}}': {{.err}}",
+ map[string]interface{}{
+ "name": entityName,
+ "err": err,
+ })
- return nestedError(errMsg, err)
+ return nestedError(errMsg, err)
}
-func handleInvocationError(err error, entityName string, parameters interface{}) (error) {
- whisk.Debug(
- whisk.DbgError,
- "Client.Actions.Invoke(%s, %s, %t) error: %s\n",
- entityName, parameters,
- Flags.common.blocking,
- err)
-
- errMsg := wski18n.T(
- "Unable to invoke action '{{.name}}': {{.err}}",
- map[string]interface{}{
- "name": entityName,
- "err": err,
- })
-
- return nestedError(errMsg, err)
+func handleInvocationError(err error, entityName string, parameters interface{}) error {
+ whisk.Debug(
+ whisk.DbgError,
+ "Client.Actions.Invoke(%s, %s, %t) error: %s\n",
+ entityName, parameters,
+ Flags.common.blocking,
+ err)
+
+ errMsg := wski18n.T(
+ "Unable to invoke action '{{.name}}': {{.err}}",
+ map[string]interface{}{
+ "name": entityName,
+ "err": err,
+ })
+
+ return nestedError(errMsg, err)
}
-func actionListError(entityName string, options *whisk.ActionListOptions, err error) (error) {
- whisk.Debug(whisk.DbgError, "Client.Actions.List(%s, %#v) error: %s\n", entityName, options, err)
+func actionListError(entityName string, options *whisk.ActionListOptions, err error) error {
+ whisk.Debug(whisk.DbgError, "Client.Actions.List(%s, %#v) error: %s\n", entityName, options, err)
- errMsg := wski18n.T(
- "Unable to obtain the list of actions for namespace '{{.name}}': {{.err}}",
- map[string]interface{}{
- "name": getClientNamespace(),
- "err": err,
- })
+ errMsg := wski18n.T(
+ "Unable to obtain the list of actions for namespace '{{.name}}': {{.err}}",
+ map[string]interface{}{
+ "name": getClientNamespace(),
+ "err": err,
+ })
- return nestedError(errMsg, err)
+ return nestedError(errMsg, err)
}
-func webInputError(arg string) (error) {
- errMsg := wski18n.T(
- "Invalid argument '{{.arg}}' for --web flag. Valid input consist of 'yes', 'true', 'raw', 'false', or 'no'.",
- map[string]interface{}{
- "arg": arg,
- })
+func webInputError(arg string) error {
+ errMsg := wski18n.T(
+ "Invalid argument '{{.arg}}' for --web flag. Valid input consist of 'yes', 'true', 'raw', 'false', or 'no'.",
+ map[string]interface{}{
+ "arg": arg,
+ })
- return nonNestedError(errMsg)
+ return nonNestedError(errMsg)
}
-func zipKindError() (error) {
- errMsg := wski18n.T("creating an action from a .zip artifact requires specifying the action kind explicitly")
+func zipKindError() error {
+ errMsg := wski18n.T("creating an action from a .zip artifact requires specifying the action kind explicitly")
- return nonNestedError(errMsg)
+ return nonNestedError(errMsg)
}
-func noArtifactError() (error) {
- errMsg := wski18n.T("An action name and code artifact are required.")
+func noArtifactError() error {
+ errMsg := wski18n.T("An action name and code artifact are required.")
- return nonNestedError(errMsg)
+ return nonNestedError(errMsg)
}
-func extensionError(extension string) (error) {
- errMsg := wski18n.T(
- "'{{.name}}' is not a supported action runtime",
- map[string]interface{}{
- "name": extension,
- })
+func extensionError(extension string) error {
+ errMsg := wski18n.T(
+ "'{{.name}}' is not a supported action runtime",
+ map[string]interface{}{
+ "name": extension,
+ })
- return nonNestedError(errMsg)
+ return nonNestedError(errMsg)
}
-func javaEntryError() (error) {
- errMsg := wski18n.T("Java actions require --main to specify the fully-qualified name of the main class")
+func javaEntryError() error {
+ errMsg := wski18n.T("Java actions require --main to specify the fully-qualified name of the main class")
- return nonNestedError(errMsg)
+ return nonNestedError(errMsg)
}
-func cannotSaveImageError() (error) {
- return nonNestedError(wski18n.T("Cannot save Docker images"))
+func cannotSaveImageError() error {
+ return nonNestedError(wski18n.T("Cannot save Docker images"))
}
-func cannotSaveSequenceError() (error) {
- return nonNestedError(wski18n.T("Cannot save action sequences"))
+func cannotSaveSequenceError() error {
+ return nonNestedError(wski18n.T("Cannot save action sequences"))
}
-func fileExistsError(file string) (error) {
- errMsg := wski18n.T("The file '{{.file}}' already exists", map[string]interface{} {
- "file": file,
- })
+func fileExistsError(file string) error {
+ errMsg := wski18n.T("The file '{{.file}}' already exists", map[string]interface{}{
+ "file": file,
+ })
- return nonNestedError(errMsg)
+ return nonNestedError(errMsg)
}
func printActionCreated(entityName string) {
- fmt.Fprintf(
- color.Output,
- wski18n.T(
- "{{.ok}} created action {{.name}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "name": boldString(entityName),
- }))
+ fmt.Fprintf(
+ color.Output,
+ wski18n.T(
+ "{{.ok}} created action {{.name}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "name": boldString(entityName),
+ }))
}
func printActionUpdated(entityName string) {
- fmt.Fprintf(
- color.Output,
- wski18n.T(
- "{{.ok}} updated action {{.name}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "name": boldString(entityName),
- }))
+ fmt.Fprintf(
+ color.Output,
+ wski18n.T(
+ "{{.ok}} updated action {{.name}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "name": boldString(entityName),
+ }))
}
func printBlockingTimeoutMsg(namespace string, entityName string, activationID interface{}) {
- fmt.Fprintf(
- colorable.NewColorableStderr(),
- wski18n.T(
- "{{.ok}} invoked /{{.namespace}}/{{.name}}, but the request has not yet finished, with id {{.id}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "namespace": boldString(namespace),
- "name": boldString(entityName),
- "id": boldString(activationID),
- }))
+ fmt.Fprintf(
+ colorable.NewColorableStderr(),
+ wski18n.T(
+ "{{.ok}} invoked /{{.namespace}}/{{.name}}, but the request has not yet finished, with id {{.id}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "namespace": boldString(namespace),
+ "name": boldString(entityName),
+ "id": boldString(activationID),
+ }))
}
func printInvocationMsg(
- namespace string,
- entityName string,
- activationID interface{},
- response map[string]interface{},
- outputStream io.Writer) {
- if !Flags.action.result {
- fmt.Fprintf(
- outputStream,
- wski18n.T(
- "{{.ok}} invoked /{{.namespace}}/{{.name}} with id {{.id}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "namespace": boldString(namespace),
- "name": boldString(entityName),
- "id": boldString(activationID),
- }))
- }
-
- if Flags.common.blocking {
- printJSON(response, outputStream)
- }
+ namespace string,
+ entityName string,
+ activationID interface{},
+ response map[string]interface{},
+ outputStream io.Writer) {
+ if !Flags.action.result {
+ fmt.Fprintf(
+ outputStream,
+ wski18n.T(
+ "{{.ok}} invoked /{{.namespace}}/{{.name}} with id {{.id}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "namespace": boldString(namespace),
+ "name": boldString(entityName),
+ "id": boldString(activationID),
+ }))
+ }
+
+ if Flags.common.blocking {
+ printJSON(response, outputStream)
+ }
}
func printActionGetWithField(entityName string, field string, action *whisk.Action) {
- fmt.Fprintf(
- color.Output,
- wski18n.T(
- "{{.ok}} got action {{.name}}, displaying field {{.field}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "name": boldString(entityName),
- "field": boldString(field),
- }))
-
- printField(action, field)
+ fmt.Fprintf(
+ color.Output,
+ wski18n.T(
+ "{{.ok}} got action {{.name}}, displaying field {{.field}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "name": boldString(entityName),
+ "field": boldString(field),
+ }))
+
+ printField(action, field)
}
func printActionGetWithURL(entityName string, actionURL string) {
- fmt.Fprintf(
- color.Output,
- wski18n.T("{{.ok}} got action {{.name}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "name": boldString(entityName),
- }))
- fmt.Println(actionURL)
+ fmt.Fprintf(
+ color.Output,
+ wski18n.T("{{.ok}} got action {{.name}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "name": boldString(entityName),
+ }))
+ fmt.Println(actionURL)
}
func printActionGet(entityName string, action *whisk.Action) {
- fmt.Fprintf(
- color.Output,
- wski18n.T("{{.ok}} got action {{.name}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "name": boldString(entityName),
- }))
-
- printJSON(action)
+ fmt.Fprintf(
+ color.Output,
+ wski18n.T("{{.ok}} got action {{.name}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "name": boldString(entityName),
+ }))
+
+ printJSON(action)
}
func printActionDeleted(entityName string) {
- fmt.Fprintf(
- color.Output,
- wski18n.T(
- "{{.ok}} deleted action {{.name}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "name": boldString(entityName),
- }))
+ fmt.Fprintf(
+ color.Output,
+ wski18n.T(
+ "{{.ok}} deleted action {{.name}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "name": boldString(entityName),
+ }))
}
func printSavedActionCodeSuccess(name string) {
- fmt.Fprintf(
- color.Output,
- wski18n.T(
- "{{.ok}} saved action code to {{.name}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "name": boldString(name),
- }))
+ fmt.Fprintf(
+ color.Output,
+ wski18n.T(
+ "{{.ok}} saved action code to {{.name}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "name": boldString(name),
+ }))
}
// Check if the specified action is a web-action
-func isWebAction(client *whisk.Client, qname QualifiedName) (error) {
- var err error = nil
-
- savedNs := client.Namespace
- client.Namespace = qname.GetNamespace()
- fullActionName := "/" + qname.GetNamespace() + "/" + qname.GetEntityName()
-
- action, _, err := client.Actions.Get(qname.GetEntityName())
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "client.Actions.Get(%s) error: %s\n", fullActionName, err)
- whisk.Debug(whisk.DbgError, "Unable to obtain action '%s' for web action validation\n", fullActionName)
- errMsg := wski18n.T("Unable to get action '{{.name}}': {{.err}}",
- map[string]interface{}{"name": fullActionName, "err": err})
- err = whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG,
- whisk.NO_DISPLAY_USAGE)
- } else {
- err = errors.New(wski18n.T("Action '{{.name}}' is not a web action. Issue 'wsk action update \"{{.name}}\" --web true' to convert the action to a web action.",
- map[string]interface{}{"name": fullActionName}))
-
- if action.WebAction() {
- err = nil
- }
- }
-
- client.Namespace = savedNs
-
- return err
+func isWebAction(client *whisk.Client, qname QualifiedName) error {
+ var err error = nil
+
+ savedNs := client.Namespace
+ client.Namespace = qname.GetNamespace()
+ fullActionName := "/" + qname.GetNamespace() + "/" + qname.GetEntityName()
+
+ action, _, err := client.Actions.Get(qname.GetEntityName())
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "client.Actions.Get(%s) error: %s\n", fullActionName, err)
+ whisk.Debug(whisk.DbgError, "Unable to obtain action '%s' for web action validation\n", fullActionName)
+ errMsg := wski18n.T("Unable to get action '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": fullActionName, "err": err})
+ err = whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG,
+ whisk.NO_DISPLAY_USAGE)
+ } else {
+ err = errors.New(wski18n.T("Action '{{.name}}' is not a web action. Issue 'wsk action update \"{{.name}}\" --web true' to convert the action to a web action.",
+ map[string]interface{}{"name": fullActionName}))
+
+ if action.WebAction() {
+ err = nil
+ }
+ }
+
+ client.Namespace = savedNs
+
+ return err
}
func init() {
- actionCreateCmd.Flags().BoolVar(&Flags.action.native, "native", false, wski18n.T("treat ACTION as native action (zip file provides a compatible executable to run)"))
- actionCreateCmd.Flags().StringVar(&Flags.action.docker, "docker", "", wski18n.T("use provided docker image (a path on DockerHub) to run the action"))
- actionCreateCmd.Flags().BoolVar(&Flags.action.copy, "copy", false, wski18n.T("treat ACTION as the name of an existing action"))
- actionCreateCmd.Flags().BoolVar(&Flags.action.sequence, "sequence", false, wski18n.T("treat ACTION as comma separated sequence of actions to invoke"))
- actionCreateCmd.Flags().StringVar(&Flags.action.kind, "kind", "", wski18n.T("the `KIND` of the action runtime (example: swift:default, nodejs:default)"))
- actionCreateCmd.Flags().StringVar(&Flags.action.main, "main", "", wski18n.T("the name of the action entry point (function or fully-qualified method name when applicable)"))
- actionCreateCmd.Flags().IntVarP(&Flags.action.timeout, TIMEOUT_FLAG, "t", TIMEOUT_LIMIT, wski18n.T("the timeout `LIMIT` in milliseconds after which the action is terminated"))
- actionCreateCmd.Flags().IntVarP(&Flags.action.memory, MEMORY_FLAG, "m", MEMORY_LIMIT, wski18n.T("the maximum memory `LIMIT` in MB for the action"))
- actionCreateCmd.Flags().IntVarP(&Flags.action.logsize, LOG_SIZE_FLAG, "l", LOGSIZE_LIMIT, wski18n.T("the maximum log size `LIMIT` in MB for the action"))
- actionCreateCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", nil, wski18n.T("annotation values in `KEY VALUE` format"))
- actionCreateCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
- actionCreateCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", nil, wski18n.T("parameter values in `KEY VALUE` format"))
- actionCreateCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
- actionCreateCmd.Flags().StringVar(&Flags.action.web, WEB_FLAG, "", wski18n.T("treat ACTION as a web action, a raw HTTP web action, or as a standard action; yes | true = web action, raw = raw HTTP web action, no | false = standard action"))
-
- actionUpdateCmd.Flags().BoolVar(&Flags.action.native, "native", false, wski18n.T("treat ACTION as native action (zip file provides a compatible executable to run)"))
- actionUpdateCmd.Flags().StringVar(&Flags.action.docker, "docker", "", wski18n.T("use provided docker image (a path on DockerHub) to run the action"))
- actionUpdateCmd.Flags().BoolVar(&Flags.action.copy, "copy", false, wski18n.T("treat ACTION as the name of an existing action"))
- actionUpdateCmd.Flags().BoolVar(&Flags.action.sequence, "sequence", false, wski18n.T("treat ACTION as comma separated sequence of actions to invoke"))
- actionUpdateCmd.Flags().StringVar(&Flags.action.kind, "kind", "", wski18n.T("the `KIND` of the action runtime (example: swift:default, nodejs:default)"))
- actionUpdateCmd.Flags().StringVar(&Flags.action.main, "main", "", wski18n.T("the name of the action entry point (function or fully-qualified method name when applicable)"))
- actionUpdateCmd.Flags().IntVarP(&Flags.action.timeout, TIMEOUT_FLAG, "t", TIMEOUT_LIMIT, wski18n.T("the timeout `LIMIT` in milliseconds after which the action is terminated"))
- actionUpdateCmd.Flags().IntVarP(&Flags.action.memory, MEMORY_FLAG, "m", MEMORY_LIMIT, wski18n.T("the maximum memory `LIMIT` in MB for the action"))
- actionUpdateCmd.Flags().IntVarP(&Flags.action.logsize, LOG_SIZE_FLAG, "l", LOGSIZE_LIMIT, wski18n.T("the maximum log size `LIMIT` in MB for the action"))
- actionUpdateCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", []string{}, wski18n.T("annotation values in `KEY VALUE` format"))
- actionUpdateCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
- actionUpdateCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
- actionUpdateCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
- actionUpdateCmd.Flags().StringVar(&Flags.action.web, WEB_FLAG, "", wski18n.T("treat ACTION as a web action, a raw HTTP web action, or as a standard action; yes | true = web action, raw = raw HTTP web action, no | false = standard action"))
-
- actionInvokeCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
- actionInvokeCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
- actionInvokeCmd.Flags().BoolVarP(&Flags.common.blocking, "blocking", "b", false, wski18n.T("blocking invoke"))
- actionInvokeCmd.Flags().BoolVarP(&Flags.action.result, "result", "r", false, wski18n.T("blocking invoke; show only activation result (unless there is a failure)"))
-
- actionGetCmd.Flags().BoolVarP(&Flags.common.summary, "summary", "s", false, wski18n.T("summarize action details; parameters with prefix \"*\" are bound, \"**\" are bound and finalized"))
- actionGetCmd.Flags().BoolVarP(&Flags.action.url, "url", "r", false, wski18n.T("get action url"))
- actionGetCmd.Flags().StringVar(&Flags.action.saveAs, SAVE_AS_FLAG, "", wski18n.T("file to save action code to"))
- actionGetCmd.Flags().BoolVarP(&Flags.action.save, SAVE_FLAG, "", false, wski18n.T("save action code to file corresponding with action name"))
-
- actionListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of actions from the result"))
- actionListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", 30, wski18n.T("only return `LIMIT` number of actions from the collection"))
- actionListCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by entity name; only applicable within the limit/skip returned entity block"))
-
- actionCmd.AddCommand(
- actionCreateCmd,
- actionUpdateCmd,
- actionInvokeCmd,
- actionGetCmd,
- actionDeleteCmd,
- actionListCmd,
- )
+ actionCreateCmd.Flags().BoolVar(&Flags.action.native, "native", false, wski18n.T("treat ACTION as native action (zip file provides a compatible executable to run)"))
+ actionCreateCmd.Flags().StringVar(&Flags.action.docker, "docker", "", wski18n.T("use provided docker image (a path on DockerHub) to run the action"))
+ actionCreateCmd.Flags().BoolVar(&Flags.action.copy, "copy", false, wski18n.T("treat ACTION as the name of an existing action"))
+ actionCreateCmd.Flags().BoolVar(&Flags.action.sequence, "sequence", false, wski18n.T("treat ACTION as comma separated sequence of actions to invoke"))
+ actionCreateCmd.Flags().StringVar(&Flags.action.kind, "kind", "", wski18n.T("the `KIND` of the action runtime (example: swift:default, nodejs:default)"))
+ actionCreateCmd.Flags().StringVar(&Flags.action.main, "main", "", wski18n.T("the name of the action entry point (function or fully-qualified method name when applicable)"))
+ actionCreateCmd.Flags().IntVarP(&Flags.action.timeout, TIMEOUT_FLAG, "t", TIMEOUT_LIMIT, wski18n.T("the timeout `LIMIT` in milliseconds after which the action is terminated"))
+ actionCreateCmd.Flags().IntVarP(&Flags.action.memory, MEMORY_FLAG, "m", MEMORY_LIMIT, wski18n.T("the maximum memory `LIMIT` in MB for the action"))
+ actionCreateCmd.Flags().IntVarP(&Flags.action.logsize, LOG_SIZE_FLAG, "l", LOGSIZE_LIMIT, wski18n.T("the maximum log size `LIMIT` in MB for the action"))
+ actionCreateCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", nil, wski18n.T("annotation values in `KEY VALUE` format"))
+ actionCreateCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
+ actionCreateCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", nil, wski18n.T("parameter values in `KEY VALUE` format"))
+ actionCreateCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
+ actionCreateCmd.Flags().StringVar(&Flags.action.web, WEB_FLAG, "", wski18n.T("treat ACTION as a web action, a raw HTTP web action, or as a standard action; yes | true = web action, raw = raw HTTP web action, no | false = standard action"))
+
+ actionUpdateCmd.Flags().BoolVar(&Flags.action.native, "native", false, wski18n.T("treat ACTION as native action (zip file provides a compatible executable to run)"))
+ actionUpdateCmd.Flags().StringVar(&Flags.action.docker, "docker", "", wski18n.T("use provided docker image (a path on DockerHub) to run the action"))
+ actionUpdateCmd.Flags().BoolVar(&Flags.action.copy, "copy", false, wski18n.T("treat ACTION as the name of an existing action"))
+ actionUpdateCmd.Flags().BoolVar(&Flags.action.sequence, "sequence", false, wski18n.T("treat ACTION as comma separated sequence of actions to invoke"))
+ actionUpdateCmd.Flags().StringVar(&Flags.action.kind, "kind", "", wski18n.T("the `KIND` of the action runtime (example: swift:default, nodejs:default)"))
+ actionUpdateCmd.Flags().StringVar(&Flags.action.main, "main", "", wski18n.T("the name of the action entry point (function or fully-qualified method name when applicable)"))
+ actionUpdateCmd.Flags().IntVarP(&Flags.action.timeout, TIMEOUT_FLAG, "t", TIMEOUT_LIMIT, wski18n.T("the timeout `LIMIT` in milliseconds after which the action is terminated"))
+ actionUpdateCmd.Flags().IntVarP(&Flags.action.memory, MEMORY_FLAG, "m", MEMORY_LIMIT, wski18n.T("the maximum memory `LIMIT` in MB for the action"))
+ actionUpdateCmd.Flags().IntVarP(&Flags.action.logsize, LOG_SIZE_FLAG, "l", LOGSIZE_LIMIT, wski18n.T("the maximum log size `LIMIT` in MB for the action"))
+ actionUpdateCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", []string{}, wski18n.T("annotation values in `KEY VALUE` format"))
+ actionUpdateCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
+ actionUpdateCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
+ actionUpdateCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
+ actionUpdateCmd.Flags().StringVar(&Flags.action.web, WEB_FLAG, "", wski18n.T("treat ACTION as a web action, a raw HTTP web action, or as a standard action; yes | true = web action, raw = raw HTTP web action, no | false = standard action"))
+
+ actionInvokeCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
+ actionInvokeCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
+ actionInvokeCmd.Flags().BoolVarP(&Flags.common.blocking, "blocking", "b", false, wski18n.T("blocking invoke"))
+ actionInvokeCmd.Flags().BoolVarP(&Flags.action.result, "result", "r", false, wski18n.T("blocking invoke; show only activation result (unless there is a failure)"))
+
+ actionGetCmd.Flags().BoolVarP(&Flags.common.summary, "summary", "s", false, wski18n.T("summarize action details; parameters with prefix \"*\" are bound, \"**\" are bound and finalized"))
+ actionGetCmd.Flags().BoolVarP(&Flags.action.url, "url", "r", false, wski18n.T("get action url"))
+ actionGetCmd.Flags().StringVar(&Flags.action.saveAs, SAVE_AS_FLAG, "", wski18n.T("file to save action code to"))
+ actionGetCmd.Flags().BoolVarP(&Flags.action.save, SAVE_FLAG, "", false, wski18n.T("save action code to file corresponding with action name"))
+
+ actionListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of actions from the result"))
+ actionListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", 30, wski18n.T("only return `LIMIT` number of actions from the collection"))
+ actionListCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by entity name; only applicable within the limit/skip returned entity block"))
+
+ actionCmd.AddCommand(
+ actionCreateCmd,
+ actionUpdateCmd,
+ actionInvokeCmd,
+ actionGetCmd,
+ actionDeleteCmd,
+ actionListCmd,
+ )
}
diff --git a/commands/activation.go b/commands/activation.go
index 22713b7..a360270 100644
--- a/commands/activation.go
+++ b/commands/activation.go
@@ -18,403 +18,403 @@
package commands
import (
- "errors"
- "fmt"
- "os"
- "os/signal"
- "syscall"
- "time"
-
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
-
- "github.com/fatih/color"
- "github.com/spf13/cobra"
+ "errors"
+ "fmt"
+ "os"
+ "os/signal"
+ "syscall"
+ "time"
+
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
+
+ "github.com/fatih/color"
+ "github.com/spf13/cobra"
)
const (
- PollInterval = time.Second * 2
- Delay = time.Second * 5
- MAX_ACTIVATION_LIMIT = 200
- DEFAULT_ACTIVATION_LIMIT = 30
+ PollInterval = time.Second * 2
+ Delay = time.Second * 5
+ MAX_ACTIVATION_LIMIT = 200
+ DEFAULT_ACTIVATION_LIMIT = 30
)
var activationCmd = &cobra.Command{
- Use: "activation",
- Short: wski18n.T("work with activations"),
+ Use: "activation",
+ Short: wski18n.T("work with activations"),
}
var activationListCmd = &cobra.Command{
- Use: "list [NAMESPACE or NAME]",
- Short: wski18n.T("list activations"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 0, 1, "Activation list",
- wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
- return whiskErr
- }
-
- // Specifying an activation item name filter is optional
- if len(args) == 1 {
- whisk.Debug(whisk.DbgInfo, "Activation item name filter '%s' provided\n", args[0])
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- }
-
- options := &whisk.ActivationListOptions{
- Name: qualifiedName.GetEntityName(),
- Limit: Flags.common.limit,
- Skip: Flags.common.skip,
- Upto: Flags.activation.upto,
- Since: Flags.activation.since,
- Docs: Flags.common.full,
- }
-
- activations, _, err := Client.Activations.List(options)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Activations.List() error: %s\n", err)
- errStr := wski18n.T("Unable to obtain the list of activations for namespace '{{.name}}': {{.err}}",
- map[string]interface{}{"name": getClientNamespace(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- // When the --full (URL contains "?docs=true") option is specified, display the entire activation details
- if options.Docs == true {
- printFullActivationList(activations)
- } else {
- printList(activations, false) // Default sorting for Activations are by creation time, hence sortByName is always false
- }
-
- return nil
- },
+ Use: "list [NAMESPACE or NAME]",
+ Short: wski18n.T("list activations"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 0, 1, "Activation list",
+ wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ // Specifying an activation item name filter is optional
+ if len(args) == 1 {
+ whisk.Debug(whisk.DbgInfo, "Activation item name filter '%s' provided\n", args[0])
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ }
+
+ options := &whisk.ActivationListOptions{
+ Name: qualifiedName.GetEntityName(),
+ Limit: Flags.common.limit,
+ Skip: Flags.common.skip,
+ Upto: Flags.activation.upto,
+ Since: Flags.activation.since,
+ Docs: Flags.common.full,
+ }
+
+ activations, _, err := Client.Activations.List(options)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Activations.List() error: %s\n", err)
+ errStr := wski18n.T("Unable to obtain the list of activations for namespace '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": getClientNamespace(), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ // When the --full (URL contains "?docs=true") option is specified, display the entire activation details
+ if options.Docs == true {
+ printFullActivationList(activations)
+ } else {
+ printList(activations, false) // Default sorting for Activations are by creation time, hence sortByName is always false
+ }
+
+ return nil
+ },
}
var activationGetCmd = &cobra.Command{
- Use: "get (ACTIVATION_ID | --last) [FIELD_FILTER]",
- Short: wski18n.T("get activation"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var field string
- var err error
-
- if args, err = lastFlag(args); err != nil { // Checks if any errors occured in lastFlag(args)
- whisk.Debug(whisk.DbgError, "lastFlag(%#v) failed: %s\n", args, err)
- errStr := wski18n.T("Unable to get activation: {{.err}}",
- map[string]interface{}{"err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- if whiskErr := CheckArgs(args, 1, 2, "Activation get",
- wski18n.T("An activation ID is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if len(args) > 1 {
- field = args[1]
-
- if !fieldExists(&whisk.Activation{}, field) {
- errMsg := wski18n.T("Invalid field filter '{{.arg}}'.", map[string]interface{}{"arg": field})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
- }
-
- id := args[0]
- activation, _, err := Client.Activations.Get(id)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Activations.Get(%s) failed: %s\n", id, err)
- errStr := wski18n.T("Unable to get activation '{{.id}}': {{.err}}",
- map[string]interface{}{"id": id, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- if Flags.common.summary {
- fmt.Printf(
- wski18n.T("activation result for '/{{.namespace}}/{{.name}}' ({{.status}} at {{.time}})\n",
- map[string]interface{}{
- "namespace": activation.Namespace,
- "name": activation.Name,
- "status": activation.Response.Status,
- "time": time.Unix(activation.End/1000, 0)}))
- printJSON(activation.Response.Result)
- } else {
-
- if len(field) > 0 {
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} got activation {{.id}}, displaying field {{.field}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "id": boldString(id),
- "field": boldString(field)}))
- printField(activation, field)
- } else {
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got activation {{.id}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "id": boldString(id)}))
- printJSON(activation)
- }
- }
-
- return nil
- },
+ Use: "get (ACTIVATION_ID | --last) [FIELD_FILTER]",
+ Short: wski18n.T("get activation"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var field string
+ var err error
+
+ if args, err = lastFlag(args); err != nil { // Checks if any errors occured in lastFlag(args)
+ whisk.Debug(whisk.DbgError, "lastFlag(%#v) failed: %s\n", args, err)
+ errStr := wski18n.T("Unable to get activation: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ if whiskErr := CheckArgs(args, 1, 2, "Activation get",
+ wski18n.T("An activation ID is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if len(args) > 1 {
+ field = args[1]
+
+ if !fieldExists(&whisk.Activation{}, field) {
+ errMsg := wski18n.T("Invalid field filter '{{.arg}}'.", map[string]interface{}{"arg": field})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ }
+
+ id := args[0]
+ activation, _, err := Client.Activations.Get(id)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Activations.Get(%s) failed: %s\n", id, err)
+ errStr := wski18n.T("Unable to get activation '{{.id}}': {{.err}}",
+ map[string]interface{}{"id": id, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ if Flags.common.summary {
+ fmt.Printf(
+ wski18n.T("activation result for '/{{.namespace}}/{{.name}}' ({{.status}} at {{.time}})\n",
+ map[string]interface{}{
+ "namespace": activation.Namespace,
+ "name": activation.Name,
+ "status": activation.Response.Status,
+ "time": time.Unix(activation.End/1000, 0)}))
+ printJSON(activation.Response.Result)
+ } else {
+
+ if len(field) > 0 {
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} got activation {{.id}}, displaying field {{.field}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "id": boldString(id),
+ "field": boldString(field)}))
+ printField(activation, field)
+ } else {
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got activation {{.id}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "id": boldString(id)}))
+ printJSON(activation)
+ }
+ }
+
+ return nil
+ },
}
var activationLogsCmd = &cobra.Command{
- Use: "logs (ACTIVATION_ID | --last)",
- Short: wski18n.T("get the logs of an activation"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
-
- if args, err = lastFlag(args); err != nil { // Checks if any errors occured in lastFlag(args)
- whisk.Debug(whisk.DbgError, "lastFlag(%#v) failed: %s\n", args, err)
- errStr := wski18n.T("Unable to get logs for activation: {{.err}}",
- map[string]interface{}{"err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- if whiskErr := CheckArgs(args, 1, 1, "Activation logs",
- wski18n.T("An activation ID is required.")); whiskErr != nil {
- return whiskErr
- }
-
- id := args[0]
- activation, _, err := Client.Activations.Logs(id)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Activations.Logs(%s) failed: %s\n", id, err)
- errStr := wski18n.T("Unable to get logs for activation '{{.id}}': {{.err}}",
- map[string]interface{}{"id": id, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- printActivationLogs(activation.Logs)
- return nil
- },
+ Use: "logs (ACTIVATION_ID | --last)",
+ Short: wski18n.T("get the logs of an activation"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+
+ if args, err = lastFlag(args); err != nil { // Checks if any errors occured in lastFlag(args)
+ whisk.Debug(whisk.DbgError, "lastFlag(%#v) failed: %s\n", args, err)
+ errStr := wski18n.T("Unable to get logs for activation: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ if whiskErr := CheckArgs(args, 1, 1, "Activation logs",
+ wski18n.T("An activation ID is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ id := args[0]
+ activation, _, err := Client.Activations.Logs(id)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Activations.Logs(%s) failed: %s\n", id, err)
+ errStr := wski18n.T("Unable to get logs for activation '{{.id}}': {{.err}}",
+ map[string]interface{}{"id": id, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ printActivationLogs(activation.Logs)
+ return nil
+ },
}
var activationResultCmd = &cobra.Command{
- Use: "result (ACTIVATION_ID | --last)",
- Short: "get the result of an activation",
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
-
- if args, err = lastFlag(args); err != nil { // Checks if any errors occured in lastFlag(args)
- whisk.Debug(whisk.DbgError, "lastFlag(%#v) failed: %s\n", args, err)
- errStr := wski18n.T("Unable to get result for activation: {{.err}}",
- map[string]interface{}{"err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- if whiskErr := CheckArgs(args, 1, 1, "Activation result",
- wski18n.T("An activation ID is required.")); whiskErr != nil {
- return whiskErr
- }
-
- id := args[0]
- result, _, err := Client.Activations.Result(id)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Activations.result(%s) failed: %s\n", id, err)
- errStr := wski18n.T("Unable to get result for activation '{{.id}}': {{.err}}",
- map[string]interface{}{"id": id, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- printJSON(result.Result)
- return nil
- },
+ Use: "result (ACTIVATION_ID | --last)",
+ Short: "get the result of an activation",
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+
+ if args, err = lastFlag(args); err != nil { // Checks if any errors occured in lastFlag(args)
+ whisk.Debug(whisk.DbgError, "lastFlag(%#v) failed: %s\n", args, err)
+ errStr := wski18n.T("Unable to get result for activation: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ if whiskErr := CheckArgs(args, 1, 1, "Activation result",
+ wski18n.T("An activation ID is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ id := args[0]
+ result, _, err := Client.Activations.Result(id)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Activations.result(%s) failed: %s\n", id, err)
+ errStr := wski18n.T("Unable to get result for activation '{{.id}}': {{.err}}",
+ map[string]interface{}{"id": id, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ printJSON(result.Result)
+ return nil
+ },
}
// lastFlag(args) retrieves the last activation with flag -l or --last
// Param: Brings in []strings from args
// Return: Returns a []string with the latest ID or the original args and any errors
func lastFlag(args []string) ([]string, error) {
- if Flags.activation.last {
- options := &whisk.ActivationListOptions {
- Limit: 1,
- Skip: 0,
- }
- activations,_, err := Client.Activations.List(options)
- if err != nil { // Checks Activations.List for errors when retrieving latest activaiton
- whisk.Debug(whisk.DbgError, "Client.Activations.List(%#v) error during lastFlag: %s\n", options, err)
- return args, err
- }
- if len(activations) == 0 { // Checks to to see if there are activations available
- whisk.Debug(whisk.DbgError, "No activations found in activation list\n")
- errStr := wski18n.T("Activation list does not contain any activations.")
- whiskErr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return args, whiskErr
- }
- if len(args) == 0 {
- whisk.Debug(whisk.DbgInfo, "Appending most recent activation ID(%s) into args\n", activations[0].ActivationID)
- args = append(args, activations[0].ActivationID)
- } else {
- whisk.Debug(whisk.DbgInfo, "Appending most recent activation ID(%s) into args\n", activations[0].ActivationID)
- args = append(args, activations[0].ActivationID)
- whisk.Debug(whisk.DbgInfo, "Allocating appended ID to correct position in args\n")
- args[0], args[len(args) - 1] = args[len(args) - 1], args[0] // IDs should be located at args[0], if 1 or more arguments are given ID has to be moved to args[0]
- }
- }
- return args, nil
+ if Flags.activation.last {
+ options := &whisk.ActivationListOptions{
+ Limit: 1,
+ Skip: 0,
+ }
+ activations, _, err := Client.Activations.List(options)
+ if err != nil { // Checks Activations.List for errors when retrieving latest activaiton
+ whisk.Debug(whisk.DbgError, "Client.Activations.List(%#v) error during lastFlag: %s\n", options, err)
+ return args, err
+ }
+ if len(activations) == 0 { // Checks to to see if there are activations available
+ whisk.Debug(whisk.DbgError, "No activations found in activation list\n")
+ errStr := wski18n.T("Activation list does not contain any activations.")
+ whiskErr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return args, whiskErr
+ }
+ if len(args) == 0 {
+ whisk.Debug(whisk.DbgInfo, "Appending most recent activation ID(%s) into args\n", activations[0].ActivationID)
+ args = append(args, activations[0].ActivationID)
+ } else {
+ whisk.Debug(whisk.DbgInfo, "Appending most recent activation ID(%s) into args\n", activations[0].ActivationID)
+ args = append(args, activations[0].ActivationID)
+ whisk.Debug(whisk.DbgInfo, "Allocating appended ID to correct position in args\n")
+ args[0], args[len(args)-1] = args[len(args)-1], args[0] // IDs should be located at args[0], if 1 or more arguments are given ID has to be moved to args[0]
+ }
+ }
+ return args, nil
}
var activationPollCmd = &cobra.Command{
- Use: "poll [ NAMESPACE | ACTION_NAME ]",
- Short: wski18n.T("poll continuously for log messages from currently running actions"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var name string
- var pollSince int64 // Represents an instant in time (in milliseconds since Jan 1 1970)
-
- if len(args) == 1 {
- name = args[0]
- } else if whiskErr := CheckArgs(args, 0, 1, "Activation poll",
- wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
- return whiskErr
- }
-
- c := make(chan os.Signal, 1)
- signal.Notify(c, os.Interrupt)
- signal.Notify(c, syscall.SIGTERM)
- go func() {
- <-c
- fmt.Println(wski18n.T("Poll terminated"))
- os.Exit(1)
- }()
- fmt.Println(wski18n.T("Enter Ctrl-c to exit."))
-
- // Map used to track activation records already displayed to the console
- reported := make(map[string]bool)
-
- if Flags.activation.sinceSeconds+
- Flags.activation.sinceMinutes+
- Flags.activation.sinceHours+
- Flags.activation.sinceDays ==
- 0 {
- options := &whisk.ActivationListOptions{
- Limit: 1,
- Docs: true,
- }
- activationList, _, err := Client.Activations.List(options)
- if err != nil {
- whisk.Debug(whisk.DbgWarn, "Client.Activations.List() error: %s\n", err)
- whisk.Debug(whisk.DbgWarn, "Ignoring Client.Activations.List failure; polling for activations since 'now'\n")
- pollSince = time.Now().Unix() * 1000 // Convert to milliseconds
- } else {
- if len(activationList) > 0 {
- lastActivation := activationList[0] // Activation.Start is in milliseconds since Jan 1 1970
- pollSince = lastActivation.Start + 1 // Use it's start time as the basis of the polling
- }
- }
- } else {
- pollSince = time.Now().Unix() * 1000 // Convert to milliseconds
-
- // ParseDuration takes a string like "2h45m15s"; create this duration string from the command arguments
- durationStr := fmt.Sprintf("%dh%dm%ds",
- Flags.activation.sinceHours + Flags.activation.sinceDays*24,
- Flags.activation.sinceMinutes,
- Flags.activation.sinceSeconds,
- )
- duration, err := time.ParseDuration(durationStr)
- if err == nil {
- pollSince = pollSince - duration.Nanoseconds()/1000/1000 // Convert to milliseconds
- } else {
- whisk.Debug(whisk.DbgError, "time.ParseDuration(%s) failure: %s\n", durationStr, err)
- }
- }
-
- fmt.Printf(wski18n.T("Polling for activation logs\n"))
- whisk.Verbose("Polling starts from %s\n", time.Unix(pollSince/1000, 0))
- localStartTime := time.Now()
-
- // Polling loop
- for {
- if Flags.activation.exit > 0 {
- localDuration := time.Since(localStartTime)
- if int(localDuration.Seconds()) > Flags.activation.exit {
- whisk.Debug(whisk.DbgInfo, "Poll time (%d seconds) expired; polling loop stopped\n", Flags.activation.exit)
- return nil
- }
- }
- whisk.Verbose("Polling for activations since %s\n", time.Unix(pollSince/1000, 0))
- options := &whisk.ActivationListOptions{
- Name: name,
- Since: pollSince,
- Docs: true,
- Limit: 0,
- Skip: 0,
- }
-
- activations, _, err := Client.Activations.List(options)
- if err != nil {
- whisk.Debug(whisk.DbgWarn, "Client.Activations.List() error: %s\n", err)
- whisk.Debug(whisk.DbgWarn, "Ignoring Client.Activations.List failure; continuing to poll for activations\n")
- continue
- }
-
- for _, activation := range activations {
- if reported[activation.ActivationID] == true {
- continue
- } else {
- fmt.Printf(
- wski18n.T("\nActivation: '{{.name}}' ({{.id}})\n",
- map[string]interface{}{"name": activation.Name, "id": activation.ActivationID}))
- printJSON(activation.Logs)
- reported[activation.ActivationID] = true
- }
- }
- time.Sleep(time.Second * 2)
- }
- return nil
- },
+ Use: "poll [ NAMESPACE | ACTION_NAME ]",
+ Short: wski18n.T("poll continuously for log messages from currently running actions"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var name string
+ var pollSince int64 // Represents an instant in time (in milliseconds since Jan 1 1970)
+
+ if len(args) == 1 {
+ name = args[0]
+ } else if whiskErr := CheckArgs(args, 0, 1, "Activation poll",
+ wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ c := make(chan os.Signal, 1)
+ signal.Notify(c, os.Interrupt)
+ signal.Notify(c, syscall.SIGTERM)
+ go func() {
+ <-c
+ fmt.Println(wski18n.T("Poll terminated"))
+ os.Exit(1)
+ }()
+ fmt.Println(wski18n.T("Enter Ctrl-c to exit."))
+
+ // Map used to track activation records already displayed to the console
+ reported := make(map[string]bool)
+
+ if Flags.activation.sinceSeconds+
+ Flags.activation.sinceMinutes+
+ Flags.activation.sinceHours+
+ Flags.activation.sinceDays ==
+ 0 {
+ options := &whisk.ActivationListOptions{
+ Limit: 1,
+ Docs: true,
+ }
+ activationList, _, err := Client.Activations.List(options)
+ if err != nil {
+ whisk.Debug(whisk.DbgWarn, "Client.Activations.List() error: %s\n", err)
+ whisk.Debug(whisk.DbgWarn, "Ignoring Client.Activations.List failure; polling for activations since 'now'\n")
+ pollSince = time.Now().Unix() * 1000 // Convert to milliseconds
+ } else {
+ if len(activationList) > 0 {
+ lastActivation := activationList[0] // Activation.Start is in milliseconds since Jan 1 1970
+ pollSince = lastActivation.Start + 1 // Use it's start time as the basis of the polling
+ }
+ }
+ } else {
+ pollSince = time.Now().Unix() * 1000 // Convert to milliseconds
+
+ // ParseDuration takes a string like "2h45m15s"; create this duration string from the command arguments
+ durationStr := fmt.Sprintf("%dh%dm%ds",
+ Flags.activation.sinceHours+Flags.activation.sinceDays*24,
+ Flags.activation.sinceMinutes,
+ Flags.activation.sinceSeconds,
+ )
+ duration, err := time.ParseDuration(durationStr)
+ if err == nil {
+ pollSince = pollSince - duration.Nanoseconds()/1000/1000 // Convert to milliseconds
+ } else {
+ whisk.Debug(whisk.DbgError, "time.ParseDuration(%s) failure: %s\n", durationStr, err)
+ }
+ }
+
+ fmt.Printf(wski18n.T("Polling for activation logs\n"))
+ whisk.Verbose("Polling starts from %s\n", time.Unix(pollSince/1000, 0))
+ localStartTime := time.Now()
+
+ // Polling loop
+ for {
+ if Flags.activation.exit > 0 {
+ localDuration := time.Since(localStartTime)
+ if int(localDuration.Seconds()) > Flags.activation.exit {
+ whisk.Debug(whisk.DbgInfo, "Poll time (%d seconds) expired; polling loop stopped\n", Flags.activation.exit)
+ return nil
+ }
+ }
+ whisk.Verbose("Polling for activations since %s\n", time.Unix(pollSince/1000, 0))
+ options := &whisk.ActivationListOptions{
+ Name: name,
+ Since: pollSince,
+ Docs: true,
+ Limit: 0,
+ Skip: 0,
+ }
+
+ activations, _, err := Client.Activations.List(options)
+ if err != nil {
+ whisk.Debug(whisk.DbgWarn, "Client.Activations.List() error: %s\n", err)
+ whisk.Debug(whisk.DbgWarn, "Ignoring Client.Activations.List failure; continuing to poll for activations\n")
+ continue
+ }
+
+ for _, activation := range activations {
+ if reported[activation.ActivationID] == true {
+ continue
+ } else {
+ fmt.Printf(
+ wski18n.T("\nActivation: '{{.name}}' ({{.id}})\n",
+ map[string]interface{}{"name": activation.Name, "id": activation.ActivationID}))
+ printJSON(activation.Logs)
+ reported[activation.ActivationID] = true
+ }
+ }
+ time.Sleep(time.Second * 2)
+ }
+ return nil
+ },
}
func init() {
- activationListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of activations from the result"))
- activationListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", DEFAULT_ACTIVATION_LIMIT, wski18n.T("only return `LIMIT` number of activations from the collection with a maximum LIMIT of {{.max}} activations",
- map[string]interface{}{"max": MAX_ACTIVATION_LIMIT}))
- activationListCmd.Flags().BoolVarP(&Flags.common.full, "full", "f", false, wski18n.T("include full activation description"))
- activationListCmd.Flags().Int64Var(&Flags.activation.upto, "upto", 0, wski18n.T("return activations with timestamps earlier than `UPTO`; measured in milliseconds since Th, 01, Jan 1970"))
- activationListCmd.Flags().Int64Var(&Flags.activation.since, "since", 0, wski18n.T("return activations with timestamps later than `SINCE`; measured in milliseconds since Th, 01, Jan 1970"))
-
- activationGetCmd.Flags().BoolVarP(&Flags.common.summary, "summary", "s", false, wski18n.T("summarize activation details"))
- activationGetCmd.Flags().BoolVarP(&Flags.activation.last, "last", "l", false, wski18n.T("retrieves the last activation"))
-
- activationLogsCmd.Flags().BoolVarP(&Flags.activation.last, "last", "l", false, wski18n.T("retrieves the last activation"))
- activationLogsCmd.Flags().BoolVarP(&Flags.activation.strip, "strip", "r", false, wski18n.T("strip timestamp and stream information"))
- activationResultCmd.Flags().BoolVarP(&Flags.activation.last, "last", "l", false, wski18n.T("retrieves the last activation"))
-
- activationPollCmd.Flags().IntVarP(&Flags.activation.exit, "exit", "e", 0, wski18n.T("stop polling after `SECONDS` seconds"))
- activationPollCmd.Flags().IntVar(&Flags.activation.sinceSeconds, "since-seconds", 0, wski18n.T("start polling for activations `SECONDS` seconds ago"))
- activationPollCmd.Flags().IntVar(&Flags.activation.sinceMinutes, "since-minutes", 0, wski18n.T("start polling for activations `MINUTES` minutes ago"))
- activationPollCmd.Flags().IntVar(&Flags.activation.sinceHours, "since-hours", 0, wski18n.T("start polling for activations `HOURS` hours ago"))
- activationPollCmd.Flags().IntVar(&Flags.activation.sinceDays, "since-days", 0, wski18n.T("start polling for activations `DAYS` days ago"))
-
- activationCmd.AddCommand(
- activationListCmd,
- activationGetCmd,
- activationLogsCmd,
- activationResultCmd,
- activationPollCmd,
- )
+ activationListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of activations from the result"))
+ activationListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", DEFAULT_ACTIVATION_LIMIT, wski18n.T("only return `LIMIT` number of activations from the collection with a maximum LIMIT of {{.max}} activations",
+ map[string]interface{}{"max": MAX_ACTIVATION_LIMIT}))
+ activationListCmd.Flags().BoolVarP(&Flags.common.full, "full", "f", false, wski18n.T("include full activation description"))
+ activationListCmd.Flags().Int64Var(&Flags.activation.upto, "upto", 0, wski18n.T("return activations with timestamps earlier than `UPTO`; measured in milliseconds since Th, 01, Jan 1970"))
+ activationListCmd.Flags().Int64Var(&Flags.activation.since, "since", 0, wski18n.T("return activations with timestamps later than `SINCE`; measured in milliseconds since Th, 01, Jan 1970"))
+
+ activationGetCmd.Flags().BoolVarP(&Flags.common.summary, "summary", "s", false, wski18n.T("summarize activation details"))
+ activationGetCmd.Flags().BoolVarP(&Flags.activation.last, "last", "l", false, wski18n.T("retrieves the last activation"))
+
+ activationLogsCmd.Flags().BoolVarP(&Flags.activation.last, "last", "l", false, wski18n.T("retrieves the last activation"))
+ activationLogsCmd.Flags().BoolVarP(&Flags.activation.strip, "strip", "r", false, wski18n.T("strip timestamp and stream information"))
+ activationResultCmd.Flags().BoolVarP(&Flags.activation.last, "last", "l", false, wski18n.T("retrieves the last activation"))
+
+ activationPollCmd.Flags().IntVarP(&Flags.activation.exit, "exit", "e", 0, wski18n.T("stop polling after `SECONDS` seconds"))
+ activationPollCmd.Flags().IntVar(&Flags.activation.sinceSeconds, "since-seconds", 0, wski18n.T("start polling for activations `SECONDS` seconds ago"))
+ activationPollCmd.Flags().IntVar(&Flags.activation.sinceMinutes, "since-minutes", 0, wski18n.T("start polling for activations `MINUTES` minutes ago"))
+ activationPollCmd.Flags().IntVar(&Flags.activation.sinceHours, "since-hours", 0, wski18n.T("start polling for activations `HOURS` hours ago"))
+ activationPollCmd.Flags().IntVar(&Flags.activation.sinceDays, "since-days", 0, wski18n.T("start polling for activations `DAYS` days ago"))
+
+ activationCmd.AddCommand(
+ activationListCmd,
+ activationGetCmd,
+ activationLogsCmd,
+ activationResultCmd,
+ activationPollCmd,
+ )
}
diff --git a/commands/api.go b/commands/api.go
index f4bc225..50b8d89 100644
--- a/commands/api.go
+++ b/commands/api.go
@@ -18,587 +18,586 @@
package commands
import (
- "bytes"
- "bufio"
- "errors"
- "fmt"
- "reflect"
- "strconv"
- "strings"
-
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
-
- "github.com/fatih/color"
- "github.com/ghodss/yaml"
- "github.com/spf13/cobra"
- "encoding/json"
+ "bufio"
+ "bytes"
+ "errors"
+ "fmt"
+ "reflect"
+ "strconv"
+ "strings"
+
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
+
+ "encoding/json"
+ "github.com/fatih/color"
+ "github.com/ghodss/yaml"
+ "github.com/spf13/cobra"
)
const (
- yamlFileExtension = "yaml"
- ymlFileExtension = "yml"
+ yamlFileExtension = "yaml"
+ ymlFileExtension = "yml"
- formatOptionYaml = "yaml"
- formatOptionJson = "json"
+ formatOptionYaml = "yaml"
+ formatOptionJson = "json"
)
var apiCmd = &cobra.Command{
- Use: "api",
- Short: wski18n.T("work with APIs"),
+ Use: "api",
+ Short: wski18n.T("work with APIs"),
}
var fmtString = "%-30s %7s %20s %s\n"
func IsValidApiVerb(verb string) (error, bool) {
- // Is the API verb valid?
- if _, ok := whisk.ApiVerbs[strings.ToUpper(verb)]; !ok {
- whisk.Debug(whisk.DbgError, "Invalid API verb: '%s'\n", verb)
- errMsg := wski18n.T("'{{.verb}}' is not a valid API verb. Valid values are: {{.verbs}}",
- map[string]interface{}{
- "verb": verb,
- "verbs": reflect.ValueOf(whisk.ApiVerbs).MapKeys()})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return whiskErr, false
- }
- return nil, true
+ // Is the API verb valid?
+ if _, ok := whisk.ApiVerbs[strings.ToUpper(verb)]; !ok {
+ whisk.Debug(whisk.DbgError, "Invalid API verb: '%s'\n", verb)
+ errMsg := wski18n.T("'{{.verb}}' is not a valid API verb. Valid values are: {{.verbs}}",
+ map[string]interface{}{
+ "verb": verb,
+ "verbs": reflect.ValueOf(whisk.ApiVerbs).MapKeys()})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whiskErr, false
+ }
+ return nil, true
}
func hasPathPrefix(path string) (error, bool) {
- if (! strings.HasPrefix(path, "/")) {
- whisk.Debug(whisk.DbgError, "path does not begin with '/': '%s'\n", path)
- errMsg := wski18n.T("'{{.path}}' must begin with '/'.",
- map[string]interface{}{
- "path": path,
- })
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return whiskErr, false
- }
- return nil, true
+ if !strings.HasPrefix(path, "/") {
+ whisk.Debug(whisk.DbgError, "path does not begin with '/': '%s'\n", path)
+ errMsg := wski18n.T("'{{.path}}' must begin with '/'.",
+ map[string]interface{}{
+ "path": path,
+ })
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whiskErr, false
+ }
+ return nil, true
}
func isValidBasepath(basepath string) (error, bool) {
- if whiskerr, ok := hasPathPrefix(basepath); !ok {
- return whiskerr, false
- }
- return nil, true
+ if whiskerr, ok := hasPathPrefix(basepath); !ok {
+ return whiskerr, false
+ }
+ return nil, true
}
func isValidRelpath(relpath string) (error, bool) {
- if whiskerr, ok := hasPathPrefix(relpath); !ok {
- return whiskerr, false
- }
- return nil, true
+ if whiskerr, ok := hasPathPrefix(relpath); !ok {
+ return whiskerr, false
+ }
+ return nil, true
}
/*
* Pull the managedUrl (external API URL) from the API configuration
*/
func getManagedUrl(api *whisk.RetApi, relpath string, operation string) (url string) {
- baseUrl := strings.TrimSuffix(api.BaseUrl, "/")
- whisk.Debug(whisk.DbgInfo, "getManagedUrl: baseUrl = '%s', relpath = '%s', operation = '%s'\n", baseUrl, relpath, operation)
- for path, _ := range api.Swagger.Paths {
- whisk.Debug(whisk.DbgInfo, "getManagedUrl: comparing api relpath: '%s'\n", path)
- if (path == relpath) {
- whisk.Debug(whisk.DbgInfo, "getManagedUrl: relpath matches '%s'\n", relpath)
- for op, _ := range api.Swagger.Paths[path] {
- whisk.Debug(whisk.DbgInfo, "getManagedUrl: comparing operation: '%s'\n", op)
- if (strings.ToLower(op) == strings.ToLower(operation)) {
- whisk.Debug(whisk.DbgInfo, "getManagedUrl: operation matches: '%s'\n", operation)
- url = baseUrl+path
- }
- }
- }
- }
- return url
+ baseUrl := strings.TrimSuffix(api.BaseUrl, "/")
+ whisk.Debug(whisk.DbgInfo, "getManagedUrl: baseUrl = '%s', relpath = '%s', operation = '%s'\n", baseUrl, relpath, operation)
+ for path, _ := range api.Swagger.Paths {
+ whisk.Debug(whisk.DbgInfo, "getManagedUrl: comparing api relpath: '%s'\n", path)
+ if path == relpath {
+ whisk.Debug(whisk.DbgInfo, "getManagedUrl: relpath matches '%s'\n", relpath)
+ for op, _ := range api.Swagger.Paths[path] {
+ whisk.Debug(whisk.DbgInfo, "getManagedUrl: comparing operation: '%s'\n", op)
+ if strings.ToLower(op) == strings.ToLower(operation) {
+ whisk.Debug(whisk.DbgInfo, "getManagedUrl: operation matches: '%s'\n", operation)
+ url = baseUrl + path
+ }
+ }
+ }
+ }
+ return url
}
//////////////
// Commands //
//////////////
var apiCreateCmd = &cobra.Command{
- Use: "create ([BASE_PATH] API_PATH API_VERB ACTION] | --config-file CFG_FILE) ",
- Short: wski18n.T("create a new API"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var api *whisk.Api
- var err error
- var qname = new(QualifiedName)
-
- if (len(args) == 0 && Flags.api.configfile == "") {
- whisk.Debug(whisk.DbgError, "No swagger file and no arguments\n")
- errMsg := wski18n.T("Invalid argument(s). Specify a swagger file or specify an API base path with an API path, an API verb, and an action name.")
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return whiskErr
- } else if (len(args) == 0 && Flags.api.configfile != "") {
- api, err = parseSwaggerApi()
- if err != nil {
- whisk.Debug(whisk.DbgError, "parseSwaggerApi() error: %s\n", err)
- errMsg := wski18n.T("Unable to parse swagger file: {{.err}}", map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return whiskErr
- }
- } else {
- if whiskErr := CheckArgs(args, 3, 4, "Api create",
- wski18n.T("Specify a swagger file or specify an API base path with an API path, an API verb, and an action name.")); whiskErr != nil {
- return whiskErr
- }
- api, qname, err = parseApi(cmd, args)
- if err != nil {
- whisk.Debug(whisk.DbgError, "parseApi(%s, %s) error: %s\n", cmd, args, err)
- errMsg := wski18n.T("Unable to parse api command arguments: {{.err}}",
- map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return whiskErr
- }
-
- // Confirm that the specified action is a web-action
- err = isWebAction(Client, *qname)
- if err != nil {
- whisk.Debug(whisk.DbgError, "isWebAction(%v) is false: %s\n", qname, err)
- whiskErr := whisk.MakeWskError(err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return whiskErr
- }
- }
-
- apiCreateReq := new(whisk.ApiCreateRequest)
- apiCreateReq.ApiDoc = api
-
- apiCreateReqOptions := new(whisk.ApiCreateRequestOptions)
- if apiCreateReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
- return err
- }
- if apiCreateReqOptions.AccessToken, err = getAccessToken(); err != nil {
- return err
- }
- apiCreateReqOptions.ResponseType = Flags.api.resptype
- whisk.Debug(whisk.DbgInfo, "AccessToken: %s\nSpaceGuid: %s\nResponsType: %s",
- apiCreateReqOptions.AccessToken, apiCreateReqOptions.SpaceGuid, apiCreateReqOptions.ResponseType)
-
- retApi, _, err := Client.Apis.Insert(apiCreateReq, apiCreateReqOptions, whisk.DoNotOverwrite)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Apis.Insert(%#v, false) error: %s\n", api, err)
- errMsg := wski18n.T("Unable to create API: {{.err}}", map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
-
- if (api.Swagger == "") {
- baseUrl := retApi.BaseUrl
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} created API {{.path}} {{.verb}} for action {{.name}}\n{{.fullpath}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "path": strings.TrimSuffix(api.GatewayBasePath, "/")+api.GatewayRelPath,
- "verb": api.GatewayMethod,
- "name": boldString("/"+api.Action.Namespace+"/"+api.Action.Name),
- "fullpath": strings.TrimSuffix(baseUrl, "/")+api.GatewayRelPath,
- }))
- } else {
- whisk.Debug(whisk.DbgInfo, "Processing swagger based create API response\n")
- baseUrl := retApi.BaseUrl
- for path, _ := range retApi.Swagger.Paths {
- managedUrl := strings.TrimSuffix(baseUrl, "/")+path
- whisk.Debug(whisk.DbgInfo, "Managed path: '%s'\n",managedUrl)
- for op, opv := range retApi.Swagger.Paths[path] {
- whisk.Debug(whisk.DbgInfo, "Path operation: '%s'\n", op)
- var fqActionName string
- if (opv.XOpenWhisk == nil) {
- fqActionName = ""
- } else if (len(opv.XOpenWhisk.Package) > 0) {
- fqActionName = "/"+opv.XOpenWhisk.Namespace+"/"+opv.XOpenWhisk.Package+"/"+opv.XOpenWhisk.ActionName
- } else {
- fqActionName = "/"+opv.XOpenWhisk.Namespace+"/"+opv.XOpenWhisk.ActionName
- }
-
- whisk.Debug(whisk.DbgInfo, "baseUrl '%s' Path '%s' Path obj %+v\n", baseUrl, path, opv)
- if len(fqActionName) > 0 {
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} created API {{.path}} {{.verb}} for action {{.name}}\n{{.fullpath}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "path": strings.TrimSuffix(retApi.Swagger.BasePath, "/") + path,
- "verb": op,
- "name": boldString(fqActionName),
- "fullpath": managedUrl,
- }))
- } else {
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} created API {{.path}} {{.verb}}\n{{.fullpath}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "path": strings.TrimSuffix(retApi.Swagger.BasePath, "/") + path,
- "verb": op,
- "fullpath": managedUrl,
- }))
- }
- }
- }
- }
-
-
- return nil
- },
+ Use: "create ([BASE_PATH] API_PATH API_VERB ACTION] | --config-file CFG_FILE) ",
+ Short: wski18n.T("create a new API"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var api *whisk.Api
+ var err error
+ var qname = new(QualifiedName)
+
+ if len(args) == 0 && Flags.api.configfile == "" {
+ whisk.Debug(whisk.DbgError, "No swagger file and no arguments\n")
+ errMsg := wski18n.T("Invalid argument(s). Specify a swagger file or specify an API base path with an API path, an API verb, and an action name.")
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whiskErr
+ } else if len(args) == 0 && Flags.api.configfile != "" {
+ api, err = parseSwaggerApi()
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "parseSwaggerApi() error: %s\n", err)
+ errMsg := wski18n.T("Unable to parse swagger file: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whiskErr
+ }
+ } else {
+ if whiskErr := CheckArgs(args, 3, 4, "Api create",
+ wski18n.T("Specify a swagger file or specify an API base path with an API path, an API verb, and an action name.")); whiskErr != nil {
+ return whiskErr
+ }
+ api, qname, err = parseApi(cmd, args)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "parseApi(%s, %s) error: %s\n", cmd, args, err)
+ errMsg := wski18n.T("Unable to parse api command arguments: {{.err}}",
+ map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ // Confirm that the specified action is a web-action
+ err = isWebAction(Client, *qname)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "isWebAction(%v) is false: %s\n", qname, err)
+ whiskErr := whisk.MakeWskError(err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whiskErr
+ }
+ }
+
+ apiCreateReq := new(whisk.ApiCreateRequest)
+ apiCreateReq.ApiDoc = api
+
+ apiCreateReqOptions := new(whisk.ApiCreateRequestOptions)
+ if apiCreateReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
+ return err
+ }
+ if apiCreateReqOptions.AccessToken, err = getAccessToken(); err != nil {
+ return err
+ }
+ apiCreateReqOptions.ResponseType = Flags.api.resptype
+ whisk.Debug(whisk.DbgInfo, "AccessToken: %s\nSpaceGuid: %s\nResponsType: %s",
+ apiCreateReqOptions.AccessToken, apiCreateReqOptions.SpaceGuid, apiCreateReqOptions.ResponseType)
+
+ retApi, _, err := Client.Apis.Insert(apiCreateReq, apiCreateReqOptions, whisk.DoNotOverwrite)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Apis.Insert(%#v, false) error: %s\n", api, err)
+ errMsg := wski18n.T("Unable to create API: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ if api.Swagger == "" {
+ baseUrl := retApi.BaseUrl
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} created API {{.path}} {{.verb}} for action {{.name}}\n{{.fullpath}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "path": strings.TrimSuffix(api.GatewayBasePath, "/") + api.GatewayRelPath,
+ "verb": api.GatewayMethod,
+ "name": boldString("/" + api.Action.Namespace + "/" + api.Action.Name),
+ "fullpath": strings.TrimSuffix(baseUrl, "/") + api.GatewayRelPath,
+ }))
+ } else {
+ whisk.Debug(whisk.DbgInfo, "Processing swagger based create API response\n")
+ baseUrl := retApi.BaseUrl
+ for path, _ := range retApi.Swagger.Paths {
+ managedUrl := strings.TrimSuffix(baseUrl, "/") + path
+ whisk.Debug(whisk.DbgInfo, "Managed path: '%s'\n", managedUrl)
+ for op, opv := range retApi.Swagger.Paths[path] {
+ whisk.Debug(whisk.DbgInfo, "Path operation: '%s'\n", op)
+ var fqActionName string
+ if opv.XOpenWhisk == nil {
+ fqActionName = ""
+ } else if len(opv.XOpenWhisk.Package) > 0 {
+ fqActionName = "/" + opv.XOpenWhisk.Namespace + "/" + opv.XOpenWhisk.Package + "/" + opv.XOpenWhisk.ActionName
+ } else {
+ fqActionName = "/" + opv.XOpenWhisk.Namespace + "/" + opv.XOpenWhisk.ActionName
+ }
+
+ whisk.Debug(whisk.DbgInfo, "baseUrl '%s' Path '%s' Path obj %+v\n", baseUrl, path, opv)
+ if len(fqActionName) > 0 {
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} created API {{.path}} {{.verb}} for action {{.name}}\n{{.fullpath}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "path": strings.TrimSuffix(retApi.Swagger.BasePath, "/") + path,
+ "verb": op,
+ "name": boldString(fqActionName),
+ "fullpath": managedUrl,
+ }))
+ } else {
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} created API {{.path}} {{.verb}}\n{{.fullpath}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "path": strings.TrimSuffix(retApi.Swagger.BasePath, "/") + path,
+ "verb": op,
+ "fullpath": managedUrl,
+ }))
+ }
+ }
+ }
+ }
+
+ return nil
+ },
}
var apiGetCmd = &cobra.Command{
- Use: "get BASE_PATH | API_NAME",
- Short: wski18n.T("get API details"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var isBasePathArg bool = true
-
- if whiskErr := CheckArgs(args, 1, 1, "Api get",
- wski18n.T("An API base path or API name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if ( cmd.LocalFlags().Changed("format") &&
- strings.ToLower(Flags.common.format) != formatOptionYaml &&
- strings.ToLower(Flags.common.format) != formatOptionJson) {
- errMsg := wski18n.T("Invalid format type: {{.type}}", map[string]interface{}{"type": Flags.common.format})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
-
- apiGetReq := new(whisk.ApiGetRequest)
- apiGetReqOptions := new(whisk.ApiGetRequestOptions)
- apiGetReqOptions.ApiBasePath = args[0]
- if apiGetReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
- return err
- }
- if apiGetReqOptions.AccessToken, err = getAccessToken(); err != nil {
- return err
- }
-
- retApi, _, err := Client.Apis.Get(apiGetReq, apiGetReqOptions)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Apis.Get(%#v, %#v) error: %s\n", apiGetReq, apiGetReqOptions, err)
- errMsg := wski18n.T("Unable to get API '{{.name}}': {{.err}}", map[string]interface{}{"name": args[0], "err": err})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
- whisk.Debug(whisk.DbgInfo, "Client.Apis.Get returned: %#v\n", retApi)
-
- var displayResult interface{} = nil
- if (Flags.common.detail) {
- if (retApi.Apis != nil && len(retApi.Apis) > 0 &&
- retApi.Apis[0].ApiValue != nil) {
- displayResult = retApi.Apis[0].ApiValue
- } else {
- whisk.Debug(whisk.DbgError, "No result object returned\n")
- }
- } else {
- if (retApi.Apis != nil && len(retApi.Apis) > 0 &&
- retApi.Apis[0].ApiValue != nil &&
- retApi.Apis[0].ApiValue.Swagger != nil) {
- displayResult = retApi.Apis[0].ApiValue.Swagger
- } else {
- whisk.Debug(whisk.DbgError, "No swagger returned\n")
- }
- }
- if (displayResult == nil) {
- var errMsg string
- if (isBasePathArg) {
- errMsg = wski18n.T("API does not exist for basepath {{.basepath}}",
- map[string]interface{}{"basepath": args[0]})
- } else {
- errMsg = wski18n.T("API does not exist for API name {{.apiname}}",
- map[string]interface{}{"apiname": args[0]})
- }
-
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
-
- if ( cmd.LocalFlags().Changed("format") && strings.ToLower(Flags.common.format) == formatOptionYaml ) {
- var jsonOutputBuffer bytes.Buffer
- var jsonOutputWriter = bufio.NewWriter(&jsonOutputBuffer)
- printJSON(displayResult, jsonOutputWriter)
- jsonOutputWriter.Flush()
- yamlbytes, err := yaml.JSONToYAML(jsonOutputBuffer.Bytes())
- if err != nil {
- whisk.Debug(whisk.DbgError, "yaml.JSONToYAML() error: %s\n", err)
- errMsg := wski18n.T("Unable to convert API into YAML: {{.err}}", map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
- fmt.Println(string(yamlbytes))
- } else {
- printJSON(displayResult)
- }
-
- return nil
- },
+ Use: "get BASE_PATH | API_NAME",
+ Short: wski18n.T("get API details"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var isBasePathArg bool = true
+
+ if whiskErr := CheckArgs(args, 1, 1, "Api get",
+ wski18n.T("An API base path or API name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if cmd.LocalFlags().Changed("format") &&
+ strings.ToLower(Flags.common.format) != formatOptionYaml &&
+ strings.ToLower(Flags.common.format) != formatOptionJson {
+ errMsg := wski18n.T("Invalid format type: {{.type}}", map[string]interface{}{"type": Flags.common.format})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ apiGetReq := new(whisk.ApiGetRequest)
+ apiGetReqOptions := new(whisk.ApiGetRequestOptions)
+ apiGetReqOptions.ApiBasePath = args[0]
+ if apiGetReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
+ return err
+ }
+ if apiGetReqOptions.AccessToken, err = getAccessToken(); err != nil {
+ return err
+ }
+
+ retApi, _, err := Client.Apis.Get(apiGetReq, apiGetReqOptions)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Apis.Get(%#v, %#v) error: %s\n", apiGetReq, apiGetReqOptions, err)
+ errMsg := wski18n.T("Unable to get API '{{.name}}': {{.err}}", map[string]interface{}{"name": args[0], "err": err})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ whisk.Debug(whisk.DbgInfo, "Client.Apis.Get returned: %#v\n", retApi)
+
+ var displayResult interface{} = nil
+ if Flags.common.detail {
+ if retApi.Apis != nil && len(retApi.Apis) > 0 &&
+ retApi.Apis[0].ApiValue != nil {
+ displayResult = retApi.Apis[0].ApiValue
+ } else {
+ whisk.Debug(whisk.DbgError, "No result object returned\n")
+ }
+ } else {
+ if retApi.Apis != nil && len(retApi.Apis) > 0 &&
+ retApi.Apis[0].ApiValue != nil &&
+ retApi.Apis[0].ApiValue.Swagger != nil {
+ displayResult = retApi.Apis[0].ApiValue.Swagger
+ } else {
+ whisk.Debug(whisk.DbgError, "No swagger returned\n")
+ }
+ }
+ if displayResult == nil {
+ var errMsg string
+ if isBasePathArg {
+ errMsg = wski18n.T("API does not exist for basepath {{.basepath}}",
+ map[string]interface{}{"basepath": args[0]})
+ } else {
+ errMsg = wski18n.T("API does not exist for API name {{.apiname}}",
+ map[string]interface{}{"apiname": args[0]})
+ }
+
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ if cmd.LocalFlags().Changed("format") && strings.ToLower(Flags.common.format) == formatOptionYaml {
+ var jsonOutputBuffer bytes.Buffer
+ var jsonOutputWriter = bufio.NewWriter(&jsonOutputBuffer)
+ printJSON(displayResult, jsonOutputWriter)
+ jsonOutputWriter.Flush()
+ yamlbytes, err := yaml.JSONToYAML(jsonOutputBuffer.Bytes())
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "yaml.JSONToYAML() error: %s\n", err)
+ errMsg := wski18n.T("Unable to convert API into YAML: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ fmt.Println(string(yamlbytes))
+ } else {
+ printJSON(displayResult)
+ }
+
+ return nil
+ },
}
var apiDeleteCmd = &cobra.Command{
- Use: "delete BASE_PATH | API_NAME [API_PATH [API_VERB]]",
- Short: wski18n.T("delete an API"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
-
- if whiskErr := CheckArgs(args, 1, 3, "Api delete",
- wski18n.T("An API base path or API name is required. An optional API relative path and operation may also be provided.")); whiskErr != nil {
- return whiskErr
- }
-
- apiDeleteReq := new(whisk.ApiDeleteRequest)
- apiDeleteReqOptions := new(whisk.ApiDeleteRequestOptions)
- if apiDeleteReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
- return err
- }
- if apiDeleteReqOptions.AccessToken, err = getAccessToken(); err != nil {
- return err
- }
-
- // Is the argument a basepath (must start with /) or an API name
- if _, ok := isValidBasepath(args[0]); !ok {
- whisk.Debug(whisk.DbgInfo, "Treating '%s' as an API name; as it does not begin with '/'\n", args[0])
- apiDeleteReqOptions.ApiBasePath = args[0]
- } else {
- apiDeleteReqOptions.ApiBasePath = args[0]
- }
-
- if (len(args) > 1) {
- // Is the API path valid?
- if whiskErr, ok := isValidRelpath(args[1]); !ok {
- return whiskErr
- }
- apiDeleteReqOptions.ApiRelPath = args[1]
- }
- if (len(args) > 2) {
- // Is the API verb valid?
- if whiskErr, ok := IsValidApiVerb(args[2]); !ok {
- return whiskErr
- }
- apiDeleteReqOptions.ApiVerb = strings.ToUpper(args[2])
- }
-
- _, err = Client.Apis.Delete(apiDeleteReq, apiDeleteReqOptions)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Apis.Delete(%#v, %#v) error: %s\n", apiDeleteReq, apiDeleteReqOptions, err)
- errMsg := wski18n.T("Unable to delete API: {{.err}}", map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
-
- if (len(args) == 1) {
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} deleted API {{.basepath}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "basepath": apiDeleteReqOptions.ApiBasePath,
- }))
- } else if (len(args) == 2 ) {
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} deleted {{.path}} from {{.basepath}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "path": apiDeleteReqOptions.ApiRelPath,
- "basepath": apiDeleteReqOptions.ApiBasePath,
- }))
- } else {
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} deleted {{.path}} {{.verb}} from {{.basepath}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "path": apiDeleteReqOptions.ApiRelPath,
- "verb": apiDeleteReqOptions.ApiVerb,
- "basepath": apiDeleteReqOptions.ApiBasePath,
- }))
- }
-
- return nil
- },
+ Use: "delete BASE_PATH | API_NAME [API_PATH [API_VERB]]",
+ Short: wski18n.T("delete an API"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+
+ if whiskErr := CheckArgs(args, 1, 3, "Api delete",
+ wski18n.T("An API base path or API name is required. An optional API relative path and operation may also be provided.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ apiDeleteReq := new(whisk.ApiDeleteRequest)
+ apiDeleteReqOptions := new(whisk.ApiDeleteRequestOptions)
+ if apiDeleteReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
+ return err
+ }
+ if apiDeleteReqOptions.AccessToken, err = getAccessToken(); err != nil {
+ return err
+ }
+
+ // Is the argument a basepath (must start with /) or an API name
+ if _, ok := isValidBasepath(args[0]); !ok {
+ whisk.Debug(whisk.DbgInfo, "Treating '%s' as an API name; as it does not begin with '/'\n", args[0])
+ apiDeleteReqOptions.ApiBasePath = args[0]
+ } else {
+ apiDeleteReqOptions.ApiBasePath = args[0]
+ }
+
+ if len(args) > 1 {
+ // Is the API path valid?
+ if whiskErr, ok := isValidRelpath(args[1]); !ok {
+ return whiskErr
+ }
+ apiDeleteReqOptions.ApiRelPath = args[1]
+ }
+ if len(args) > 2 {
+ // Is the API verb valid?
+ if whiskErr, ok := IsValidApiVerb(args[2]); !ok {
+ return whiskErr
+ }
+ apiDeleteReqOptions.ApiVerb = strings.ToUpper(args[2])
+ }
+
+ _, err = Client.Apis.Delete(apiDeleteReq, apiDeleteReqOptions)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Apis.Delete(%#v, %#v) error: %s\n", apiDeleteReq, apiDeleteReqOptions, err)
+ errMsg := wski18n.T("Unable to delete API: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ if len(args) == 1 {
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} deleted API {{.basepath}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "basepath": apiDeleteReqOptions.ApiBasePath,
+ }))
+ } else if len(args) == 2 {
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} deleted {{.path}} from {{.basepath}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "path": apiDeleteReqOptions.ApiRelPath,
+ "basepath": apiDeleteReqOptions.ApiBasePath,
+ }))
+ } else {
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} deleted {{.path}} {{.verb}} from {{.basepath}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "path": apiDeleteReqOptions.ApiRelPath,
+ "verb": apiDeleteReqOptions.ApiVerb,
+ "basepath": apiDeleteReqOptions.ApiBasePath,
+ }))
+ }
+
+ return nil
+ },
}
var apiListCmd = &cobra.Command{
- Use: "list [[BASE_PATH | API_NAME] [API_PATH [API_VERB]]",
- Short: wski18n.T("list APIs"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var retApiList *whisk.ApiListResponse
- var retApi *whisk.ApiGetResponse
- var retApiArray *whisk.RetApiArray
- var apiPath string
- var apiVerb string
- var orderFilteredList []whisk.ApiFilteredList
- var orderFilteredRow []whisk.ApiFilteredRow
-
- if whiskErr := CheckArgs(args, 0, 3, "Api list",
- wski18n.T("Optional parameters are: API base path (or API name), API relative path and operation.")); whiskErr != nil {
- return whiskErr
- }
-
- if (len(args) == 0) {
- // List API request query parameters
- apiListReqOptions := new(whisk.ApiListRequestOptions)
- apiListReqOptions.Limit = Flags.common.limit
- apiListReqOptions.Skip = Flags.common.skip
- if apiListReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
- return err
- }
- if apiListReqOptions.AccessToken, err = getAccessToken(); err != nil {
- return err
- }
-
- retApiList, _, err = Client.Apis.List(apiListReqOptions)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Apis.List(%#v) error: %s\n", apiListReqOptions, err)
- errMsg := wski18n.T("Unable to obtain the API list: {{.err}}", map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
- whisk.Debug(whisk.DbgInfo, "Client.Apis.List returned: %#v (%+v)\n", retApiList, retApiList)
- // Cast to a common type to allow for code to print out apilist response or apiget response
- retApiArray = (*whisk.RetApiArray)(retApiList)
- } else {
- // Get API request body
- apiGetReq := new(whisk.ApiGetRequest)
- apiGetReq.Namespace = Client.Config.Namespace
- // Get API request options
- apiGetReqOptions := new(whisk.ApiGetRequestOptions)
- if apiGetReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
- return err
- }
- if apiGetReqOptions.AccessToken, err = getAccessToken(); err != nil {
- return err
- }
-
- // The first argument is either a basepath (must start with /) or an API name
- apiGetReqOptions.ApiBasePath = args[0]
- if (len(args) > 1) {
- // Is the API path valid?
- if whiskErr, ok := isValidRelpath(args[1]); !ok {
- return whiskErr
- }
- apiPath = args[1]
- apiGetReqOptions.ApiRelPath = apiPath
- }
- if (len(args) > 2) {
- // Is the API verb valid?
- if whiskErr, ok := IsValidApiVerb(args[2]); !ok {
- return whiskErr
- }
- apiVerb = strings.ToUpper(args[2])
- apiGetReqOptions.ApiVerb = apiVerb
- }
-
- retApi, _, err = Client.Apis.Get(apiGetReq, apiGetReqOptions)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Apis.Get(%#v, %#v) error: %s\n", apiGetReq, apiGetReqOptions, err)
- errMsg := wski18n.T("Unable to obtain the API list: {{.err}}", map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
- whisk.Debug(whisk.DbgInfo, "Client.Apis.Get returned: %#v\n", retApi)
- // Cast to a common type to allow for code to print out apilist response or apiget response
- retApiArray = (*whisk.RetApiArray)(retApi)
- }
- //Checks for any order flags being passed
- sortByName := Flags.common.nameSort
- // Display the APIs - applying any specified filtering
- if (Flags.common.full) {
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} APIs\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- }))
- for i := 0; i < len(retApiArray.Apis); i++ {
- orderFilteredList = append(orderFilteredList, genFilteredList(retApiArray.Apis[i].ApiValue, apiPath, apiVerb)...)
- }
- printList(orderFilteredList, sortByName) // Sends an array of structs that contains specifed variables that are not truncated
- } else {
- if (len(retApiArray.Apis) > 0) {
- // Dynamically create the output format string based on the maximum size of the
- // fully qualified action name and the API Name.
- maxActionNameSize := min(40, max(len("Action"), getLargestActionNameSize(retApiArray, apiPath, apiVerb)))
- maxApiNameSize := min(30, max(len("API Name"), getLargestApiNameSize(retApiArray, apiPath, apiVerb)))
- fmtString = "%-"+strconv.Itoa(maxActionNameSize)+"s %7s %"+strconv.Itoa(maxApiNameSize+1)+"s %s\n"
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} APIs\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- }))
- for i := 0; i < len(retApiArray.Apis); i++ {
- orderFilteredRow = append(orderFilteredRow, genFilteredRow(retApiArray.Apis[i].ApiValue, apiPath, apiVerb, maxActionNameSize, maxApiNameSize)...)
- }
- printList(orderFilteredRow, sortByName) // Sends an array of structs that contains specifed variables that are truncated
- } else {
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} APIs\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- }))
- printList(orderFilteredRow, sortByName) // Sends empty orderFilteredRow so that defaultHeader can be printed
- }
- }
-
- return nil
- },
+ Use: "list [[BASE_PATH | API_NAME] [API_PATH [API_VERB]]",
+ Short: wski18n.T("list APIs"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var retApiList *whisk.ApiListResponse
+ var retApi *whisk.ApiGetResponse
+ var retApiArray *whisk.RetApiArray
+ var apiPath string
+ var apiVerb string
+ var orderFilteredList []whisk.ApiFilteredList
+ var orderFilteredRow []whisk.ApiFilteredRow
+
+ if whiskErr := CheckArgs(args, 0, 3, "Api list",
+ wski18n.T("Optional parameters are: API base path (or API name), API relative path and operation.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if len(args) == 0 {
+ // List API request query parameters
+ apiListReqOptions := new(whisk.ApiListRequestOptions)
+ apiListReqOptions.Limit = Flags.common.limit
+ apiListReqOptions.Skip = Flags.common.skip
+ if apiListReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
+ return err
+ }
+ if apiListReqOptions.AccessToken, err = getAccessToken(); err != nil {
+ return err
+ }
+
+ retApiList, _, err = Client.Apis.List(apiListReqOptions)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Apis.List(%#v) error: %s\n", apiListReqOptions, err)
+ errMsg := wski18n.T("Unable to obtain the API list: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ whisk.Debug(whisk.DbgInfo, "Client.Apis.List returned: %#v (%+v)\n", retApiList, retApiList)
+ // Cast to a common type to allow for code to print out apilist response or apiget response
+ retApiArray = (*whisk.RetApiArray)(retApiList)
+ } else {
+ // Get API request body
+ apiGetReq := new(whisk.ApiGetRequest)
+ apiGetReq.Namespace = Client.Config.Namespace
+ // Get API request options
+ apiGetReqOptions := new(whisk.ApiGetRequestOptions)
+ if apiGetReqOptions.SpaceGuid, err = getUserContextId(); err != nil {
+ return err
+ }
+ if apiGetReqOptions.AccessToken, err = getAccessToken(); err != nil {
+ return err
+ }
+
+ // The first argument is either a basepath (must start with /) or an API name
+ apiGetReqOptions.ApiBasePath = args[0]
+ if len(args) > 1 {
+ // Is the API path valid?
+ if whiskErr, ok := isValidRelpath(args[1]); !ok {
+ return whiskErr
+ }
+ apiPath = args[1]
+ apiGetReqOptions.ApiRelPath = apiPath
+ }
+ if len(args) > 2 {
+ // Is the API verb valid?
+ if whiskErr, ok := IsValidApiVerb(args[2]); !ok {
+ return whiskErr
+ }
+ apiVerb = strings.ToUpper(args[2])
+ apiGetReqOptions.ApiVerb = apiVerb
+ }
+
+ retApi, _, err = Client.Apis.Get(apiGetReq, apiGetReqOptions)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Apis.Get(%#v, %#v) error: %s\n", apiGetReq, apiGetReqOptions, err)
+ errMsg := wski18n.T("Unable to obtain the API list: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ whisk.Debug(whisk.DbgInfo, "Client.Apis.Get returned: %#v\n", retApi)
+ // Cast to a common type to allow for code to print out apilist response or apiget response
+ retApiArray = (*whisk.RetApiArray)(retApi)
+ }
+ //Checks for any order flags being passed
+ sortByName := Flags.common.nameSort
+ // Display the APIs - applying any specified filtering
+ if Flags.common.full {
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} APIs\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ }))
+ for i := 0; i < len(retApiArray.Apis); i++ {
+ orderFilteredList = append(orderFilteredList, genFilteredList(retApiArray.Apis[i].ApiValue, apiPath, apiVerb)...)
+ }
+ printList(orderFilteredList, sortByName) // Sends an array of structs that contains specifed variables that are not truncated
+ } else {
+ if len(retApiArray.Apis) > 0 {
+ // Dynamically create the output format string based on the maximum size of the
+ // fully qualified action name and the API Name.
+ maxActionNameSize := min(40, max(len("Action"), getLargestActionNameSize(retApiArray, apiPath, apiVerb)))
+ maxApiNameSize := min(30, max(len("API Name"), getLargestApiNameSize(retApiArray, apiPath, apiVerb)))
+ fmtString = "%-" + strconv.Itoa(maxActionNameSize) + "s %7s %" + strconv.Itoa(maxApiNameSize+1) + "s %s\n"
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} APIs\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ }))
+ for i := 0; i < len(retApiArray.Apis); i++ {
+ orderFilteredRow = append(orderFilteredRow, genFilteredRow(retApiArray.Apis[i].ApiValue, apiPath, apiVerb, maxActionNameSize, maxApiNameSize)...)
+ }
+ printList(orderFilteredRow, sortByName) // Sends an array of structs that contains specifed variables that are truncated
+ } else {
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} APIs\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ }))
+ printList(orderFilteredRow, sortByName) // Sends empty orderFilteredRow so that defaultHeader can be printed
+ }
+ }
+
+ return nil
+ },
}
// genFilteredList(resultApi, api) generates an array of
// ApiFilteredLists for the purpose of ordering and printing in a list form.
// NOTE: genFilteredRow() generates entries with one line per configuration
// property (action name, verb, api name, api gw url)
-func genFilteredList(resultApi *whisk.RetApi, apiPath string, apiVerb string) []whisk.ApiFilteredList{
- var orderInfo whisk.ApiFilteredList
- var orderInfoArr []whisk.ApiFilteredList
- baseUrl := strings.TrimSuffix(resultApi.BaseUrl, "/")
- apiName := resultApi.Swagger.Info.Title
- basePath := resultApi.Swagger.BasePath
- if (resultApi.Swagger != nil && resultApi.Swagger.Paths != nil) {
- for path, _ := range resultApi.Swagger.Paths {
- whisk.Debug(whisk.DbgInfo, "genFilteredApi: comparing api relpath: '%s'\n", path)
- if ( len(apiPath) == 0 || path == apiPath) {
- whisk.Debug(whisk.DbgInfo, "genFilteredList: relpath matches\n")
- for op, opv := range resultApi.Swagger.Paths[path] {
- whisk.Debug(whisk.DbgInfo, "genFilteredList: comparing operation: '%s'\n", op)
- if ( len(apiVerb) == 0 || strings.ToLower(op) == strings.ToLower(apiVerb)) {
- whisk.Debug(whisk.DbgInfo, "genFilteredList: operation matches: %#v\n", opv)
- var actionName string
- if (opv.XOpenWhisk == nil) {
- actionName = ""
- } else if (len(opv.XOpenWhisk.Package) > 0) {
- actionName = "/"+opv.XOpenWhisk.Namespace+"/"+opv.XOpenWhisk.Package+"/"+opv.XOpenWhisk.ActionName
- } else {
- actionName = "/"+opv.XOpenWhisk.Namespace+"/"+opv.XOpenWhisk.ActionName
- }
- orderInfo = AssignListInfo(actionName, op, apiName, basePath, path, baseUrl+path)
- whisk.Debug(whisk.DbgInfo, "Appening to orderInfoArr: %s %s\n", orderInfo.RelPath)
- orderInfoArr = append(orderInfoArr, orderInfo)
- }
- }
- }
- }
- }
- return orderInfoArr
+func genFilteredList(resultApi *whisk.RetApi, apiPath string, apiVerb string) []whisk.ApiFilteredList {
+ var orderInfo whisk.ApiFilteredList
+ var orderInfoArr []whisk.ApiFilteredList
+ baseUrl := strings.TrimSuffix(resultApi.BaseUrl, "/")
+ apiName := resultApi.Swagger.Info.Title
+ basePath := resultApi.Swagger.BasePath
+ if resultApi.Swagger != nil && resultApi.Swagger.Paths != nil {
+ for path, _ := range resultApi.Swagger.Paths {
+ whisk.Debug(whisk.DbgInfo, "genFilteredApi: comparing api relpath: '%s'\n", path)
+ if len(apiPath) == 0 || path == apiPath {
+ whisk.Debug(whisk.DbgInfo, "genFilteredList: relpath matches\n")
+ for op, opv := range resultApi.Swagger.Paths[path] {
+ whisk.Debug(whisk.DbgInfo, "genFilteredList: comparing operation: '%s'\n", op)
+ if len(apiVerb) == 0 || strings.ToLower(op) == strings.ToLower(apiVerb) {
+ whisk.Debug(whisk.DbgInfo, "genFilteredList: operation matches: %#v\n", opv)
+ var actionName string
+ if opv.XOpenWhisk == nil {
+ actionName = ""
+ } else if len(opv.XOpenWhisk.Package) > 0 {
+ actionName = "/" + opv.XOpenWhisk.Namespace + "/" + opv.XOpenWhisk.Package + "/" + opv.XOpenWhisk.ActionName
+ } else {
+ actionName = "/" + opv.XOpenWhisk.Namespace + "/" + opv.XOpenWhisk.ActionName
+ }
+ orderInfo = AssignListInfo(actionName, op, apiName, basePath, path, baseUrl+path)
+ whisk.Debug(whisk.DbgInfo, "Appening to orderInfoArr: %s %s\n", orderInfo.RelPath)
+ orderInfoArr = append(orderInfoArr, orderInfo)
+ }
+ }
+ }
+ }
+ }
+ return orderInfoArr
}
// genFilteredRow(resultApi, api, maxApiNameSize, maxApiNameSize) generates an array of
@@ -606,127 +605,127 @@ func genFilteredList(resultApi *whisk.RetApi, apiPath string, apiVerb string) []
// initializing vaules for each individual ApiFilteredRow struct.
// NOTE: Large action and api name values will be truncated by their associated max size parameters.
func genFilteredRow(resultApi *whisk.RetApi, apiPath string, apiVerb string, maxActionNameSize int, maxApiNameSize int) []whisk.ApiFilteredRow {
- var orderInfo whisk.ApiFilteredRow
- var orderInfoArr []whisk.ApiFilteredRow
- baseUrl := strings.TrimSuffix(resultApi.BaseUrl, "/")
- apiName := resultApi.Swagger.Info.Title
- basePath := resultApi.Swagger.BasePath
- if (resultApi.Swagger != nil && resultApi.Swagger.Paths != nil) {
- for path, _ := range resultApi.Swagger.Paths {
- whisk.Debug(whisk.DbgInfo, "genFilteredRow: comparing api relpath: '%s'\n", path)
- if ( len(apiPath) == 0 || path == apiPath) {
- whisk.Debug(whisk.DbgInfo, "genFilteredRow: relpath matches\n")
- for op, opv := range resultApi.Swagger.Paths[path] {
- whisk.Debug(whisk.DbgInfo, "genFilteredRow: comparing operation: '%s'\n", op)
- if ( len(apiVerb) == 0 || strings.ToLower(op) == strings.ToLower(apiVerb)) {
- whisk.Debug(whisk.DbgInfo, "genFilteredRow: operation matches: %#v\n", opv)
- var actionName string
- if (opv.XOpenWhisk == nil) {
- actionName = ""
- } else if (len(opv.XOpenWhisk.Package) > 0) {
- actionName = "/"+opv.XOpenWhisk.Namespace+"/"+opv.XOpenWhisk.Package+"/"+opv.XOpenWhisk.ActionName
- } else {
- actionName = "/"+opv.XOpenWhisk.Namespace+"/"+opv.XOpenWhisk.ActionName
- }
- orderInfo = AssignRowInfo(actionName[0 : min(len(actionName), maxActionNameSize)], op, apiName[0 : min(len(apiName), maxApiNameSize)], basePath, path, baseUrl+path)
- orderInfo.FmtString = fmtString
- whisk.Debug(whisk.DbgInfo, "Appening to orderInfoArr: %s %s\n", orderInfo.RelPath)
- orderInfoArr = append(orderInfoArr, orderInfo)
- }
- }
- }
- }
- }
- return orderInfoArr
+ var orderInfo whisk.ApiFilteredRow
+ var orderInfoArr []whisk.ApiFilteredRow
+ baseUrl := strings.TrimSuffix(resultApi.BaseUrl, "/")
+ apiName := resultApi.Swagger.Info.Title
+ basePath := resultApi.Swagger.BasePath
+ if resultApi.Swagger != nil && resultApi.Swagger.Paths != nil {
+ for path, _ := range resultApi.Swagger.Paths {
+ whisk.Debug(whisk.DbgInfo, "genFilteredRow: comparing api relpath: '%s'\n", path)
+ if len(apiPath) == 0 || path == apiPath {
+ whisk.Debug(whisk.DbgInfo, "genFilteredRow: relpath matches\n")
+ for op, opv := range resultApi.Swagger.Paths[path] {
+ whisk.Debug(whisk.DbgInfo, "genFilteredRow: comparing operation: '%s'\n", op)
+ if len(apiVerb) == 0 || strings.ToLower(op) == strings.ToLower(apiVerb) {
+ whisk.Debug(whisk.DbgInfo, "genFilteredRow: operation matches: %#v\n", opv)
+ var actionName string
+ if opv.XOpenWhisk == nil {
+ actionName = ""
+ } else if len(opv.XOpenWhisk.Package) > 0 {
+ actionName = "/" + opv.XOpenWhisk.Namespace + "/" + opv.XOpenWhisk.Package + "/" + opv.XOpenWhisk.ActionName
+ } else {
+ actionName = "/" + opv.XOpenWhisk.Namespace + "/" + opv.XOpenWhisk.ActionName
+ }
+ orderInfo = AssignRowInfo(actionName[0:min(len(actionName), maxActionNameSize)], op, apiName[0:min(len(apiName), maxApiNameSize)], basePath, path, baseUrl+path)
+ orderInfo.FmtString = fmtString
+ whisk.Debug(whisk.DbgInfo, "Appening to orderInfoArr: %s %s\n", orderInfo.RelPath)
+ orderInfoArr = append(orderInfoArr, orderInfo)
+ }
+ }
+ }
+ }
+ }
+ return orderInfoArr
}
// AssignRowInfo(actionName, verb, apiName, basePath, relPath, url) assigns
// the given vaules to and initializes an ApiFilteredRow struct, then returns it.
func AssignRowInfo(actionName string, verb string, apiName string, basePath string, relPath string, url string) whisk.ApiFilteredRow {
- var orderInfo whisk.ApiFilteredRow
+ var orderInfo whisk.ApiFilteredRow
- orderInfo.ActionName = actionName
- orderInfo.Verb = verb
- orderInfo.ApiName = apiName
- orderInfo.BasePath = basePath
- orderInfo.RelPath = relPath
- orderInfo.Url = url
+ orderInfo.ActionName = actionName
+ orderInfo.Verb = verb
+ orderInfo.ApiName = apiName
+ orderInfo.BasePath = basePath
+ orderInfo.RelPath = relPath
+ orderInfo.Url = url
- return orderInfo
+ return orderInfo
}
// AssignListInfo(actionName, verb, apiName, basePath, relPath, url) assigns
// the given vaules to and initializes an ApiFilteredList struct, then returns it.
func AssignListInfo(actionName string, verb string, apiName string, basePath string, relPath string, url string) whisk.ApiFilteredList {
- var orderInfo whisk.ApiFilteredList
+ var orderInfo whisk.ApiFilteredList
- orderInfo.ActionName = actionName
- orderInfo.Verb = verb
- orderInfo.ApiName = apiName
- orderInfo.BasePath = basePath
- orderInfo.RelPath = relPath
- orderInfo.Url = url
+ orderInfo.ActionName = actionName
+ orderInfo.Verb = verb
+ orderInfo.ApiName = apiName
+ orderInfo.BasePath = basePath
+ orderInfo.RelPath = relPath
+ orderInfo.Url = url
- return orderInfo
+ return orderInfo
}
func getLargestActionNameSize(retApiArray *whisk.RetApiArray, apiPath string, apiVerb string) int {
- var maxNameSize = 0
- for i := 0; i < len(retApiArray.Apis); i++ {
- var resultApi = retApiArray.Apis[i].ApiValue
- if (resultApi.Swagger != nil && resultApi.Swagger.Paths != nil) {
- for path, _ := range resultApi.Swagger.Paths {
- whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: comparing api relpath: '%s'\n", path)
- if ( len(apiPath) == 0 || path == apiPath) {
- whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: relpath matches\n")
- for op, opv := range resultApi.Swagger.Paths[path] {
- whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: comparing operation: '%s'\n", op)
- if ( len(apiVerb) == 0 || strings.ToLower(op) == strings.ToLower(apiVerb)) {
- whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: operation matches: %#v\n", opv)
- var fullActionName string
- if (opv.XOpenWhisk == nil) {
- fullActionName = ""
- } else if (len(opv.XOpenWhisk.Package) > 0) {
- fullActionName = "/"+opv.XOpenWhisk.Namespace+"/"+opv.XOpenWhisk.Package+"/"+opv.XOpenWhisk.ActionName
- } else {
- fullActionName = "/"+opv.XOpenWhisk.Namespace+"/"+opv.XOpenWhisk.ActionName
- }
- if (len(fullActionName) > maxNameSize) {
- maxNameSize = len(fullActionName)
- }
- }
- }
- }
- }
- }
- }
- return maxNameSize
+ var maxNameSize = 0
+ for i := 0; i < len(retApiArray.Apis); i++ {
+ var resultApi = retApiArray.Apis[i].ApiValue
+ if resultApi.Swagger != nil && resultApi.Swagger.Paths != nil {
+ for path, _ := range resultApi.Swagger.Paths {
+ whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: comparing api relpath: '%s'\n", path)
+ if len(apiPath) == 0 || path == apiPath {
+ whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: relpath matches\n")
+ for op, opv := range resultApi.Swagger.Paths[path] {
+ whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: comparing operation: '%s'\n", op)
+ if len(apiVerb) == 0 || strings.ToLower(op) == strings.ToLower(apiVerb) {
+ whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: operation matches: %#v\n", opv)
+ var fullActionName string
+ if opv.XOpenWhisk == nil {
+ fullActionName = ""
+ } else if len(opv.XOpenWhisk.Package) > 0 {
+ fullActionName = "/" + opv.XOpenWhisk.Namespace + "/" + opv.XOpenWhisk.Package + "/" + opv.XOpenWhisk.ActionName
+ } else {
+ fullActionName = "/" + opv.XOpenWhisk.Namespace + "/" + opv.XOpenWhisk.ActionName
+ }
+ if len(fullActionName) > maxNameSize {
+ maxNameSize = len(fullActionName)
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return maxNameSize
}
func getLargestApiNameSize(retApiArray *whisk.RetApiArray, apiPath string, apiVerb string) int {
- var maxNameSize = 0
- for i := 0; i < len(retApiArray.Apis); i++ {
- var resultApi = retApiArray.Apis[i].ApiValue
- apiName := resultApi.Swagger.Info.Title
- if (resultApi.Swagger != nil && resultApi.Swagger.Paths != nil) {
- for path, _ := range resultApi.Swagger.Paths {
- whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: comparing api relpath: '%s'\n", path)
- if ( len(apiPath) == 0 || path == apiPath) {
- whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: relpath matches\n")
- for op, opv := range resultApi.Swagger.Paths[path] {
- whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: comparing operation: '%s'\n", op)
- if ( len(apiVerb) == 0 || strings.ToLower(op) == strings.ToLower(apiVerb)) {
- whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: operation matches: %#v\n", opv)
- if (len(apiName) > maxNameSize) {
- maxNameSize = len(apiName)
- }
- }
- }
- }
- }
- }
- }
- return maxNameSize
+ var maxNameSize = 0
+ for i := 0; i < len(retApiArray.Apis); i++ {
+ var resultApi = retApiArray.Apis[i].ApiValue
+ apiName := resultApi.Swagger.Info.Title
+ if resultApi.Swagger != nil && resultApi.Swagger.Paths != nil {
+ for path, _ := range resultApi.Swagger.Paths {
+ whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: comparing api relpath: '%s'\n", path)
+ if len(apiPath) == 0 || path == apiPath {
+ whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: relpath matches\n")
+ for op, opv := range resultApi.Swagger.Paths[path] {
+ whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: comparing operation: '%s'\n", op)
+ if len(apiVerb) == 0 || strings.ToLower(op) == strings.ToLower(apiVerb) {
+ whisk.Debug(whisk.DbgInfo, "getLargestActionNameSize: operation matches: %#v\n", opv)
+ if len(apiName) > maxNameSize {
+ maxNameSize = len(apiName)
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return maxNameSize
}
/*
@@ -742,201 +741,203 @@ func getLargestApiNameSize(retApiArray *whisk.RetApiArray, apiPath string, apiVe
* args[2] = Optional. Action name (may or may not be qualified with namespace and package name)
*/
func parseApi(cmd *cobra.Command, args []string) (*whisk.Api, *QualifiedName, error) {
- var err error
- var basepath string = "/"
- var apiname string
- var basepathArgIsApiName = false;
-
- api := new(whisk.Api)
-
- if (len(args) > 3) {
- // Is the argument a basepath (must start with /) or an API name
- if _, ok := isValidBasepath(args[0]); !ok {
- whisk.Debug(whisk.DbgInfo, "Treating '%s' as an API name; as it does not begin with '/'\n", args[0])
- basepathArgIsApiName = true;
- }
- basepath = args[0]
-
- // Shift the args so the remaining code works with or without the explicit base path arg
- args = args[1:]
- }
-
- // Is the API path valid?
- if (len(args) > 0) {
- if whiskErr, ok := isValidRelpath(args[0]); !ok {
- return nil, nil, whiskErr
- }
- api.GatewayRelPath = args[0] // Maintain case as URLs may be case-sensitive
- }
-
- // Is the API verb valid?
- if (len(args) > 1) {
- if whiskErr, ok := IsValidApiVerb(args[1]); !ok {
- return nil, nil, whiskErr
- }
- api.GatewayMethod = strings.ToUpper(args[1])
- }
-
- // Is the specified action name valid?
- var qName = new(QualifiedName)
- if (len(args) == 3) {
- qName, err = NewQualifiedName(args[2])
- if err != nil {
- whisk.Debug(whisk.DbgError, "NewQualifiedName(%s) failed: %s\n", args[2], err)
- errMsg := wski18n.T("'{{.name}}' is not a valid action name: {{.err}}",
- map[string]interface{}{"name": args[2], "err": err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
- if (qName.GetEntityName() == "") {
- whisk.Debug(whisk.DbgError, "Action name '%s' is invalid\n", args[2])
- errMsg := wski18n.T("'{{.name}}' is not a valid action name.", map[string]interface{}{"name": args[2]})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
- }
-
- if ( len(Flags.api.apiname) > 0 ) {
- if (basepathArgIsApiName) {
- // Specifying API name as argument AND as a --apiname option value is invalid
- whisk.Debug(whisk.DbgError, "API is specified as an argument '%s' and as a flag '%s'\n", basepath, Flags.api.apiname)
- errMsg := wski18n.T("An API name can only be specified once.")
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
- apiname = Flags.api.apiname
- }
-
- api.Namespace = Client.Config.Namespace
- api.Action = new(whisk.ApiAction)
- var urlActionPackage string
- if (len(qName.GetPackageName()) > 0) {
- urlActionPackage = qName.GetPackageName()
- } else {
- urlActionPackage = "default"
- }
- api.Action.BackendUrl = "https://" + Client.Config.Host + "/api/v1/web/" + qName.GetNamespace() + "/" + urlActionPackage + "/" + qName.GetEntity() + ".http"
- api.Action.BackendMethod = api.GatewayMethod
- api.Action.Name = qName.GetEntityName()
- api.Action.Namespace = qName.GetNamespace()
- api.Action.Auth = Client.Config.AuthToken
- api.ApiName = apiname
- api.GatewayBasePath = basepath
- if (!basepathArgIsApiName) { api.Id = "API:"+api.Namespace+":"+api.GatewayBasePath }
-
- whisk.Debug(whisk.DbgInfo, "Parsed api struct: %#v\n", api)
- return api, qName, nil
+ var err error
+ var basepath string = "/"
+ var apiname string
+ var basepathArgIsApiName = false
+
+ api := new(whisk.Api)
+
+ if len(args) > 3 {
+ // Is the argument a basepath (must start with /) or an API name
+ if _, ok := isValidBasepath(args[0]); !ok {
+ whisk.Debug(whisk.DbgInfo, "Treating '%s' as an API name; as it does not begin with '/'\n", args[0])
+ basepathArgIsApiName = true
+ }
+ basepath = args[0]
+
+ // Shift the args so the remaining code works with or without the explicit base path arg
+ args = args[1:]
+ }
+
+ // Is the API path valid?
+ if len(args) > 0 {
+ if whiskErr, ok := isValidRelpath(args[0]); !ok {
+ return nil, nil, whiskErr
+ }
+ api.GatewayRelPath = args[0] // Maintain case as URLs may be case-sensitive
+ }
+
+ // Is the API verb valid?
+ if len(args) > 1 {
+ if whiskErr, ok := IsValidApiVerb(args[1]); !ok {
+ return nil, nil, whiskErr
+ }
+ api.GatewayMethod = strings.ToUpper(args[1])
+ }
+
+ // Is the specified action name valid?
+ var qName = new(QualifiedName)
+ if len(args) == 3 {
+ qName, err = NewQualifiedName(args[2])
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "NewQualifiedName(%s) failed: %s\n", args[2], err)
+ errMsg := wski18n.T("'{{.name}}' is not a valid action name: {{.err}}",
+ map[string]interface{}{"name": args[2], "err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+ if qName.GetEntityName() == "" {
+ whisk.Debug(whisk.DbgError, "Action name '%s' is invalid\n", args[2])
+ errMsg := wski18n.T("'{{.name}}' is not a valid action name.", map[string]interface{}{"name": args[2]})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+ }
+
+ if len(Flags.api.apiname) > 0 {
+ if basepathArgIsApiName {
+ // Specifying API name as argument AND as a --apiname option value is invalid
+ whisk.Debug(whisk.DbgError, "API is specified as an argument '%s' and as a flag '%s'\n", basepath, Flags.api.apiname)
+ errMsg := wski18n.T("An API name can only be specified once.")
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+ apiname = Flags.api.apiname
+ }
+
+ api.Namespace = Client.Config.Namespace
+ api.Action = new(whisk.ApiAction)
+ var urlActionPackage string
+ if len(qName.GetPackageName()) > 0 {
+ urlActionPackage = qName.GetPackageName()
+ } else {
+ urlActionPackage = "default"
+ }
+ api.Action.BackendUrl = "https://" + Client.Config.Host + "/api/v1/web/" + qName.GetNamespace() + "/" + urlActionPackage + "/" + qName.GetEntity() + ".http"
+ api.Action.BackendMethod = api.GatewayMethod
+ api.Action.Name = qName.GetEntityName()
+ api.Action.Namespace = qName.GetNamespace()
+ api.Action.Auth = Client.Config.AuthToken
+ api.ApiName = apiname
+ api.GatewayBasePath = basepath
+ if !basepathArgIsApiName {
+ api.Id = "API:" + api.Namespace + ":" + api.GatewayBasePath
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Parsed api struct: %#v\n", api)
+ return api, qName, nil
}
func parseSwaggerApi() (*whisk.Api, error) {
- // Test is for completeness, but this situation should only arise due to an internal error
- if ( len(Flags.api.configfile) == 0 ) {
- whisk.Debug(whisk.DbgError, "No swagger file is specified\n")
- errMsg := wski18n.T("A configuration file was not specified.")
- whiskErr := whisk.MakeWskError(errors.New(errMsg),whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return nil, whiskErr
- }
-
- swagger, err:= ReadFile(Flags.api.configfile)
- if ( err != nil ) {
- whisk.Debug(whisk.DbgError, "readFile(%s) error: %s\n", Flags.api.configfile, err)
- errMsg := wski18n.T("Error reading swagger file '{{.name}}': {{.err}}",
- map[string]interface{}{"name": Flags.api.configfile, "err": err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return nil, whiskErr
- }
-
- // Check if this swagger is in JSON or YAML format
- isYaml := strings.HasSuffix(Flags.api.configfile, yamlFileExtension) || strings.HasSuffix(Flags.api.configfile, ymlFileExtension)
- if isYaml {
- whisk.Debug(whisk.DbgInfo, "Converting YAML formated API configuration into JSON\n")
- jsonbytes, err := yaml.YAMLToJSON([]byte(swagger))
- if err != nil {
- whisk.Debug(whisk.DbgError, "yaml.YAMLToJSON() error: %s\n", err)
- errMsg := wski18n.T("Unable to parse YAML configuration file: {{.err}}", map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return nil, whiskErr
- }
- swagger = string(jsonbytes)
- }
-
- // Parse the JSON into a swagger object
- swaggerObj := new(whisk.ApiSwagger)
- err = json.Unmarshal([]byte(swagger), swaggerObj)
- if ( err != nil ) {
- whisk.Debug(whisk.DbgError, "JSON parse of '%s' error: %s\n", Flags.api.configfile, err)
- errMsg := wski18n.T("Error parsing swagger file '{{.name}}': {{.err}}",
- map[string]interface{}{"name": Flags.api.configfile, "err": err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return nil, whiskErr
- }
- if (swaggerObj.BasePath == "" || swaggerObj.SwaggerName == "" || swaggerObj.Info == nil || swaggerObj.Paths == nil) {
- whisk.Debug(whisk.DbgError, "Swagger file is invalid.\n", Flags.api.configfile, err)
- errMsg := wski18n.T("Swagger file is invalid (missing basePath, info, paths, or swagger fields)")
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return nil, whiskErr
- }
- if _, ok := isValidBasepath(swaggerObj.BasePath); !ok {
- whisk.Debug(whisk.DbgError, "Swagger file basePath is invalid.\n", Flags.api.configfile, err)
- errMsg := wski18n.T("Swagger file basePath must start with a leading slash (/)")
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return nil, whiskErr
- }
-
- api := new(whisk.Api)
- api.Namespace = Client.Config.Namespace
- api.Swagger = swagger
-
- return api, nil
+ // Test is for completeness, but this situation should only arise due to an internal error
+ if len(Flags.api.configfile) == 0 {
+ whisk.Debug(whisk.DbgError, "No swagger file is specified\n")
+ errMsg := wski18n.T("A configuration file was not specified.")
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return nil, whiskErr
+ }
+
+ swagger, err := ReadFile(Flags.api.configfile)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "readFile(%s) error: %s\n", Flags.api.configfile, err)
+ errMsg := wski18n.T("Error reading swagger file '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": Flags.api.configfile, "err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return nil, whiskErr
+ }
+
+ // Check if this swagger is in JSON or YAML format
+ isYaml := strings.HasSuffix(Flags.api.configfile, yamlFileExtension) || strings.HasSuffix(Flags.api.configfile, ymlFileExtension)
+ if isYaml {
+ whisk.Debug(whisk.DbgInfo, "Converting YAML formated API configuration into JSON\n")
+ jsonbytes, err := yaml.YAMLToJSON([]byte(swagger))
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "yaml.YAMLToJSON() error: %s\n", err)
+ errMsg := wski18n.T("Unable to parse YAML configuration file: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return nil, whiskErr
+ }
+ swagger = string(jsonbytes)
+ }
+
+ // Parse the JSON into a swagger object
+ swaggerObj := new(whisk.ApiSwagger)
+ err = json.Unmarshal([]byte(swagger), swaggerObj)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "JSON parse of '%s' error: %s\n", Flags.api.configfile, err)
+ errMsg := wski18n.T("Error parsing swagger file '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": Flags.api.configfile, "err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return nil, whiskErr
+ }
+ if swaggerObj.BasePath == "" || swaggerObj.SwaggerName == "" || swaggerObj.Info == nil || swaggerObj.Paths == nil {
+ whisk.Debug(whisk.DbgError, "Swagger file is invalid.\n", Flags.api.configfile, err)
+ errMsg := wski18n.T("Swagger file is invalid (missing basePath, info, paths, or swagger fields)")
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return nil, whiskErr
+ }
+ if _, ok := isValidBasepath(swaggerObj.BasePath); !ok {
+ whisk.Debug(whisk.DbgError, "Swagger file basePath is invalid.\n", Flags.api.configfile, err)
+ errMsg := wski18n.T("Swagger file basePath must start with a leading slash (/)")
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return nil, whiskErr
+ }
+
+ api := new(whisk.Api)
+ api.Namespace = Client.Config.Namespace
+ api.Swagger = swagger
+
+ return api, nil
}
func getAccessToken() (string, error) {
- var token string = "DUMMY TOKEN"
- var err error
-
- props, err := ReadProps(Properties.PropsFile)
- if err == nil {
- if len(props["APIGW_ACCESS_TOKEN"]) > 0 {
- token = props["APIGW_ACCESS_TOKEN"]
- }
- } else {
- whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
- errStr := wski18n.T("Unable to obtain the API Gateway access token from the properties file: {{.err}}", map[string]interface{}{"err": err})
- err = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- }
-
- return token, err
+ var token string = "DUMMY TOKEN"
+ var err error
+
+ props, err := ReadProps(Properties.PropsFile)
+ if err == nil {
+ if len(props["APIGW_ACCESS_TOKEN"]) > 0 {
+ token = props["APIGW_ACCESS_TOKEN"]
+ }
+ } else {
+ whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
+ errStr := wski18n.T("Unable to obtain the API Gateway access token from the properties file: {{.err}}", map[string]interface{}{"err": err})
+ err = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ }
+
+ return token, err
}
func getUserContextId() (string, error) {
- var guid string
- var err error
-
- props, err := ReadProps(Properties.PropsFile)
- if err == nil {
- if len(props["AUTH"]) > 0 {
- guid = strings.Split(props["AUTH"], ":")[0]
- } else {
- whisk.Debug(whisk.DbgError, "AUTH property not set in properties file: '%s'\n", Properties.PropsFile)
- errStr := wski18n.T("Authorization key is not configured (--auth is required)")
- err = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- }
- } else {
- whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
- errStr := wski18n.T("Unable to obtain the auth key from the properties file: {{.err}}", map[string]interface{}{"err": err})
- err = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- }
-
- return guid, err
+ var guid string
+ var err error
+
+ props, err := ReadProps(Properties.PropsFile)
+ if err == nil {
+ if len(props["AUTH"]) > 0 {
+ guid = strings.Split(props["AUTH"], ":")[0]
+ } else {
+ whisk.Debug(whisk.DbgError, "AUTH property not set in properties file: '%s'\n", Properties.PropsFile)
+ errStr := wski18n.T("Authorization key is not configured (--auth is required)")
+ err = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ }
+ } else {
+ whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
+ errStr := wski18n.T("Unable to obtain the auth key from the properties file: {{.err}}", map[string]interface{}{"err": err})
+ err = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ }
+
+ return guid, err
}
///////////
@@ -945,19 +946,19 @@ func getUserContextId() (string, error) {
func init() {
- apiCreateCmd.Flags().StringVarP(&Flags.api.apiname, "apiname", "n", "", wski18n.T("Friendly name of the API; ignored when CFG_FILE is specified (default BASE_PATH)"))
- apiCreateCmd.Flags().StringVarP(&Flags.api.configfile, "config-file", "c", "", wski18n.T("`CFG_FILE` containing API configuration in swagger JSON format"))
- apiCreateCmd.Flags().StringVar(&Flags.api.resptype, "response-type", "json", wski18n.T("Set the web action response `TYPE`. Possible values are html, http, json, text, svg"))
- apiGetCmd.Flags().BoolVarP(&Flags.common.detail, "full", "f", false, wski18n.T("display full API configuration details"))
- apiGetCmd.Flags().StringVarP(&Flags.common.format, "format", "", formatOptionJson, wski18n.T("Specify the API output `TYPE`, either json or yaml"))
- apiListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of actions from the result"))
- apiListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", 30, wski18n.T("only return `LIMIT` number of actions from the collection"))
- apiListCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by order of [BASE_PATH | API_NAME], API_PATH, then API_VERB; only applicable within the limit/skip returned entity block"))
- apiListCmd.Flags().BoolVarP(&Flags.common.full, "full", "f", false, wski18n.T("display full description of each API"))
- apiCmd.AddCommand(
- apiCreateCmd,
- apiGetCmd,
- apiDeleteCmd,
- apiListCmd,
- )
+ apiCreateCmd.Flags().StringVarP(&Flags.api.apiname, "apiname", "n", "", wski18n.T("Friendly name of the API; ignored when CFG_FILE is specified (default BASE_PATH)"))
+ apiCreateCmd.Flags().StringVarP(&Flags.api.configfile, "config-file", "c", "", wski18n.T("`CFG_FILE` containing API configuration in swagger JSON format"))
+ apiCreateCmd.Flags().StringVar(&Flags.api.resptype, "response-type", "json", wski18n.T("Set the web action response `TYPE`. Possible values are html, http, json, text, svg"))
+ apiGetCmd.Flags().BoolVarP(&Flags.common.detail, "full", "f", false, wski18n.T("display full API configuration details"))
+ apiGetCmd.Flags().StringVarP(&Flags.common.format, "format", "", formatOptionJson, wski18n.T("Specify the API output `TYPE`, either json or yaml"))
+ apiListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of actions from the result"))
+ apiListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", 30, wski18n.T("only return `LIMIT` number of actions from the collection"))
+ apiListCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by order of [BASE_PATH | API_NAME], API_PATH, then API_VERB; only applicable within the limit/skip returned entity block"))
+ apiListCmd.Flags().BoolVarP(&Flags.common.full, "full", "f", false, wski18n.T("display full description of each API"))
+ apiCmd.AddCommand(
+ apiCreateCmd,
+ apiGetCmd,
+ apiDeleteCmd,
+ apiListCmd,
+ )
}
diff --git a/commands/commands.go b/commands/commands.go
index fcb5757..2fbdeb1 100644
--- a/commands/commands.go
+++ b/commands/commands.go
@@ -18,210 +18,212 @@
package commands
import (
- "errors"
- "net/http"
- "os"
+ "errors"
+ "net/http"
+ "os"
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/spf13/cobra"
+ "github.com/spf13/cobra"
)
var Client *whisk.Client
+
const DefaultOpenWhiskApiPath string = "/api"
+
var UserAgent string = "OpenWhisk-CLI"
-func SetupClientConfig(cmd *cobra.Command, args []string) (error){
- baseURL, err := whisk.GetURLBase(Properties.APIHost, DefaultOpenWhiskApiPath)
-
- // Determine if the parent command will require the API host to be set
- apiHostRequired := (cmd.Parent().Name() == "property" && cmd.Name() == "get" && (Flags.property.auth ||
- Flags.property.cert || Flags.property.key || Flags.property.apihost || Flags.property.namespace ||
- Flags.property.apiversion || Flags.property.cliversion)) ||
- (cmd.Parent().Name() == "property" && cmd.Name() == "set" && (len(Flags.property.apihostSet) > 0 ||
- len(Flags.property.apiversionSet) > 0 || len(Flags.Global.Auth) > 0)) ||
- (cmd.Parent().Name() == "sdk" && cmd.Name() == "install" && len(args) > 0 && args[0] == "bashauto")
-
- // Display an error if the parent command requires an API host to be set, and the current API host is not valid
- if err != nil && !apiHostRequired {
- whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) error: %s\n", Properties.APIHost, DefaultOpenWhiskApiPath, err)
- errMsg := wski18n.T("The API host is not valid: {{.err}}", map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
-
- clientConfig := &whisk.Config{
- Cert: Properties.Cert,
- Key: Properties.Key,
- AuthToken: Properties.Auth,
- Namespace: Properties.Namespace,
- BaseURL: baseURL,
- Version: Properties.APIVersion,
- Insecure: Flags.Global.Insecure,
- Host: Properties.APIHost,
- UserAgent: UserAgent + "/1.0 (" + Properties.CLIVersion + ")",
- }
-
- if len(clientConfig.Host) == 0 {
- config, _ := whisk.GetDefaultConfig()
- clientConfig.Host = config.Host
- if len(clientConfig.Host) == 0 {
- clientConfig.Host = "openwhisk.ng.bluemix.net"
- }
- }
-
- // Setup client
- Client, err = whisk.NewClient(http.DefaultClient, clientConfig)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "whisk.NewClient(%#v, %#v) error: %s\n", http.DefaultClient, clientConfig, err)
- errMsg := wski18n.T("Unable to initialize server connection: {{.err}}", map[string]interface{}{"err": err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return whiskErr
- }
-
- return nil
+func SetupClientConfig(cmd *cobra.Command, args []string) error {
+ baseURL, err := whisk.GetURLBase(Properties.APIHost, DefaultOpenWhiskApiPath)
+
+ // Determine if the parent command will require the API host to be set
+ apiHostRequired := (cmd.Parent().Name() == "property" && cmd.Name() == "get" && (Flags.property.auth ||
+ Flags.property.cert || Flags.property.key || Flags.property.apihost || Flags.property.namespace ||
+ Flags.property.apiversion || Flags.property.cliversion)) ||
+ (cmd.Parent().Name() == "property" && cmd.Name() == "set" && (len(Flags.property.apihostSet) > 0 ||
+ len(Flags.property.apiversionSet) > 0 || len(Flags.Global.Auth) > 0)) ||
+ (cmd.Parent().Name() == "sdk" && cmd.Name() == "install" && len(args) > 0 && args[0] == "bashauto")
+
+ // Display an error if the parent command requires an API host to be set, and the current API host is not valid
+ if err != nil && !apiHostRequired {
+ whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) error: %s\n", Properties.APIHost, DefaultOpenWhiskApiPath, err)
+ errMsg := wski18n.T("The API host is not valid: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ clientConfig := &whisk.Config{
+ Cert: Properties.Cert,
+ Key: Properties.Key,
+ AuthToken: Properties.Auth,
+ Namespace: Properties.Namespace,
+ BaseURL: baseURL,
+ Version: Properties.APIVersion,
+ Insecure: Flags.Global.Insecure,
+ Host: Properties.APIHost,
+ UserAgent: UserAgent + "/1.0 (" + Properties.CLIVersion + ")",
+ }
+
+ if len(clientConfig.Host) == 0 {
+ config, _ := whisk.GetDefaultConfig()
+ clientConfig.Host = config.Host
+ if len(clientConfig.Host) == 0 {
+ clientConfig.Host = "openwhisk.ng.bluemix.net"
+ }
+ }
+
+ // Setup client
+ Client, err = whisk.NewClient(http.DefaultClient, clientConfig)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "whisk.NewClient(%#v, %#v) error: %s\n", http.DefaultClient, clientConfig, err)
+ errMsg := wski18n.T("Unable to initialize server connection: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ return nil
}
func init() {}
func getKeyValueArgs(args []string, argIndex int, parsedArgs []string) ([]string, []string, error) {
- var whiskErr error
- var key string
- var value string
-
- if len(args) - 1 >= argIndex + 2 {
- key = args[argIndex + 1]
- value = args[argIndex + 2]
- parsedArgs = append(parsedArgs, getFormattedJSON(key, value))
- args = append(args[:argIndex], args[argIndex + 3:]...)
- } else {
- whisk.Debug(whisk.DbgError, "Arguments for '%s' must be a key/value pair; args: %s", args[argIndex], args)
- errMsg := wski18n.T("Arguments for '{{.arg}}' must be a key/value pair",
- map[string]interface{}{"arg": args[argIndex]})
- whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
- whisk.DISPLAY_USAGE)
- }
-
- return parsedArgs, args, whiskErr
+ var whiskErr error
+ var key string
+ var value string
+
+ if len(args)-1 >= argIndex+2 {
+ key = args[argIndex+1]
+ value = args[argIndex+2]
+ parsedArgs = append(parsedArgs, getFormattedJSON(key, value))
+ args = append(args[:argIndex], args[argIndex+3:]...)
+ } else {
+ whisk.Debug(whisk.DbgError, "Arguments for '%s' must be a key/value pair; args: %s", args[argIndex], args)
+ errMsg := wski18n.T("Arguments for '{{.arg}}' must be a key/value pair",
+ map[string]interface{}{"arg": args[argIndex]})
+ whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
+ whisk.DISPLAY_USAGE)
+ }
+
+ return parsedArgs, args, whiskErr
}
func getValueFromArgs(args []string, argIndex int, parsedArgs []string) ([]string, []string, error) {
- var whiskErr error
-
- if len(args) - 1 >= argIndex + 1 {
- parsedArgs = append(parsedArgs, args[argIndex + 1])
- args = append(args[:argIndex], args[argIndex + 2:]...)
- } else {
- whisk.Debug(whisk.DbgError, "An argument must be provided for '%s'; args: %s", args[argIndex], args)
- errMsg := wski18n.T("An argument must be provided for '{{.arg}}'",
- map[string]interface{}{"arg": args[argIndex]})
- whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
- whisk.DISPLAY_USAGE)
- }
-
- return parsedArgs, args, whiskErr
+ var whiskErr error
+
+ if len(args)-1 >= argIndex+1 {
+ parsedArgs = append(parsedArgs, args[argIndex+1])
+ args = append(args[:argIndex], args[argIndex+2:]...)
+ } else {
+ whisk.Debug(whisk.DbgError, "An argument must be provided for '%s'; args: %s", args[argIndex], args)
+ errMsg := wski18n.T("An argument must be provided for '{{.arg}}'",
+ map[string]interface{}{"arg": args[argIndex]})
+ whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
+ whisk.DISPLAY_USAGE)
+ }
+
+ return parsedArgs, args, whiskErr
}
func parseArgs(args []string) ([]string, []string, []string, error) {
- var paramArgs []string
- var annotArgs []string
- var whiskErr error
-
- i := 0
-
- for i < len(args) {
- if args[i] == "-P" || args[i] == "--param-file" {
- paramArgs, args, whiskErr = getValueFromArgs(args, i, paramArgs)
- if whiskErr != nil {
- whisk.Debug(whisk.DbgError, "getValueFromArgs(%#v, %d) failed: %s\n", args, i, whiskErr)
- errMsg := wski18n.T("The parameter arguments are invalid: {{.err}}",
- map[string]interface{}{"err": whiskErr})
- whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
- whisk.DISPLAY_USAGE)
- return nil, nil, nil, whiskErr
- }
-
- filename := paramArgs[len(paramArgs) - 1]
- paramArgs[len(paramArgs) - 1], whiskErr = ReadFile(filename)
- if whiskErr != nil {
- whisk.Debug(whisk.DbgError, "readFile(%s) error: %s\n", filename, whiskErr)
- return nil, nil, nil, whiskErr
- }
- } else if args[i] == "-A" || args[i] == "--annotation-file" {
- annotArgs, args, whiskErr = getValueFromArgs(args, i, annotArgs)
- if whiskErr != nil {
- whisk.Debug(whisk.DbgError, "getValueFromArgs(%#v, %d) failed: %s\n", args, i, whiskErr)
- errMsg := wski18n.T("The annotation arguments are invalid: {{.err}}",
- map[string]interface{}{"err": whiskErr})
- whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
- whisk.DISPLAY_USAGE)
- return nil, nil, nil, whiskErr
- }
-
- filename := annotArgs[len(annotArgs) - 1]
- annotArgs[len(annotArgs) - 1], whiskErr = ReadFile(filename)
- if whiskErr != nil {
- whisk.Debug(whisk.DbgError, "readFile(%s) error: %s\n", filename, whiskErr)
- return nil, nil, nil, whiskErr
- }
- } else if args[i] == "-p" || args[i] == "--param" {
- paramArgs, args, whiskErr = getKeyValueArgs(args, i, paramArgs)
- if whiskErr != nil {
- whisk.Debug(whisk.DbgError, "getKeyValueArgs(%#v, %d) failed: %s\n", args, i, whiskErr)
- errMsg := wski18n.T("The parameter arguments are invalid: {{.err}}",
- map[string]interface{}{"err": whiskErr})
- whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
- whisk.DISPLAY_USAGE)
- return nil, nil, nil, whiskErr
- }
- } else if args[i] == "-a" || args[i] == "--annotation"{
- annotArgs, args, whiskErr = getKeyValueArgs(args, i, annotArgs)
- if whiskErr != nil {
- whisk.Debug(whisk.DbgError, "getKeyValueArgs(%#v, %d) failed: %s\n", args, i, whiskErr)
- errMsg := wski18n.T("The annotation arguments are invalid: {{.err}}",
- map[string]interface{}{"err": whiskErr})
- whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
- whisk.DISPLAY_USAGE)
- return nil, nil, nil, whiskErr
- }
- } else {
- i++
- }
- }
-
- whisk.Debug(whisk.DbgInfo, "Found param args '%s'.\n", paramArgs)
- whisk.Debug(whisk.DbgInfo, "Found annotations args '%s'.\n", annotArgs)
- whisk.Debug(whisk.DbgInfo, "Arguments with param args removed '%s'.\n", args)
-
- return args, paramArgs, annotArgs, nil
+ var paramArgs []string
+ var annotArgs []string
+ var whiskErr error
+
+ i := 0
+
+ for i < len(args) {
+ if args[i] == "-P" || args[i] == "--param-file" {
+ paramArgs, args, whiskErr = getValueFromArgs(args, i, paramArgs)
+ if whiskErr != nil {
+ whisk.Debug(whisk.DbgError, "getValueFromArgs(%#v, %d) failed: %s\n", args, i, whiskErr)
+ errMsg := wski18n.T("The parameter arguments are invalid: {{.err}}",
+ map[string]interface{}{"err": whiskErr})
+ whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
+ whisk.DISPLAY_USAGE)
+ return nil, nil, nil, whiskErr
+ }
+
+ filename := paramArgs[len(paramArgs)-1]
+ paramArgs[len(paramArgs)-1], whiskErr = ReadFile(filename)
+ if whiskErr != nil {
+ whisk.Debug(whisk.DbgError, "readFile(%s) error: %s\n", filename, whiskErr)
+ return nil, nil, nil, whiskErr
+ }
+ } else if args[i] == "-A" || args[i] == "--annotation-file" {
+ annotArgs, args, whiskErr = getValueFromArgs(args, i, annotArgs)
+ if whiskErr != nil {
+ whisk.Debug(whisk.DbgError, "getValueFromArgs(%#v, %d) failed: %s\n", args, i, whiskErr)
+ errMsg := wski18n.T("The annotation arguments are invalid: {{.err}}",
+ map[string]interface{}{"err": whiskErr})
+ whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
+ whisk.DISPLAY_USAGE)
+ return nil, nil, nil, whiskErr
+ }
+
+ filename := annotArgs[len(annotArgs)-1]
+ annotArgs[len(annotArgs)-1], whiskErr = ReadFile(filename)
+ if whiskErr != nil {
+ whisk.Debug(whisk.DbgError, "readFile(%s) error: %s\n", filename, whiskErr)
+ return nil, nil, nil, whiskErr
+ }
+ } else if args[i] == "-p" || args[i] == "--param" {
+ paramArgs, args, whiskErr = getKeyValueArgs(args, i, paramArgs)
+ if whiskErr != nil {
+ whisk.Debug(whisk.DbgError, "getKeyValueArgs(%#v, %d) failed: %s\n", args, i, whiskErr)
+ errMsg := wski18n.T("The parameter arguments are invalid: {{.err}}",
+ map[string]interface{}{"err": whiskErr})
+ whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
+ whisk.DISPLAY_USAGE)
+ return nil, nil, nil, whiskErr
+ }
+ } else if args[i] == "-a" || args[i] == "--annotation" {
+ annotArgs, args, whiskErr = getKeyValueArgs(args, i, annotArgs)
+ if whiskErr != nil {
+ whisk.Debug(whisk.DbgError, "getKeyValueArgs(%#v, %d) failed: %s\n", args, i, whiskErr)
+ errMsg := wski18n.T("The annotation arguments are invalid: {{.err}}",
+ map[string]interface{}{"err": whiskErr})
+ whiskErr = whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG,
+ whisk.DISPLAY_USAGE)
+ return nil, nil, nil, whiskErr
+ }
+ } else {
+ i++
+ }
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Found param args '%s'.\n", paramArgs)
+ whisk.Debug(whisk.DbgInfo, "Found annotations args '%s'.\n", annotArgs)
+ whisk.Debug(whisk.DbgInfo, "Arguments with param args removed '%s'.\n", args)
+
+ return args, paramArgs, annotArgs, nil
}
func Execute() error {
- var err error
-
- whisk.Debug(whisk.DbgInfo, "wsk args: %#v\n", os.Args)
- os.Args, Flags.common.param, Flags.common.annotation, err = parseArgs(os.Args)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "parseParams(%s) failed: %s\n", os.Args, err)
- errMsg := wski18n.T("Failed to parse arguments: {{.err}}", map[string]interface{}{"err":err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return whiskErr
- }
-
- err = loadProperties()
- if err != nil {
- whisk.Debug(whisk.DbgError, "loadProperties() error: %s\n", err)
- errMsg := wski18n.T("Unable to access configuration properties: {{.err}}", map[string]interface{}{"err":err})
- whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return whiskErr
- }
-
- return WskCmd.Execute()
+ var err error
+
+ whisk.Debug(whisk.DbgInfo, "wsk args: %#v\n", os.Args)
+ os.Args, Flags.common.param, Flags.common.annotation, err = parseArgs(os.Args)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "parseParams(%s) failed: %s\n", os.Args, err)
+ errMsg := wski18n.T("Failed to parse arguments: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ err = loadProperties()
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "loadProperties() error: %s\n", err)
+ errMsg := wski18n.T("Unable to access configuration properties: {{.err}}", map[string]interface{}{"err": err})
+ whiskErr := whisk.MakeWskErrorFromWskError(errors.New(errMsg), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ return WskCmd.Execute()
}
diff --git a/commands/flags.go b/commands/flags.go
index 8a06d05..7229586 100644
--- a/commands/flags.go
+++ b/commands/flags.go
@@ -18,7 +18,7 @@
package commands
import (
- "os"
+ "os"
)
///////////
@@ -26,132 +26,129 @@ import (
///////////
const (
- MEMORY_FLAG = "memory"
- LOG_SIZE_FLAG = "logsize"
- TIMEOUT_FLAG = "timeout"
- WEB_FLAG = "web"
- SAVE_FLAG = "save"
- SAVE_AS_FLAG = "save-as"
+ MEMORY_FLAG = "memory"
+ LOG_SIZE_FLAG = "logsize"
+ TIMEOUT_FLAG = "timeout"
+ WEB_FLAG = "web"
+ SAVE_FLAG = "save"
+ SAVE_AS_FLAG = "save-as"
)
-
-var cliDebug = os.Getenv("WSK_CLI_DEBUG") // Useful for tracing init() code
+var cliDebug = os.Getenv("WSK_CLI_DEBUG") // Useful for tracing init() code
var Flags FlagsStruct
type FlagsStruct struct {
-
- Global struct {
- Verbose bool
- Debug bool
- Cert string
- Key string
- Auth string
- Apihost string
- Apiversion string
- Insecure bool
- }
-
- common struct {
- blocking bool
- annotation []string
- annotFile string
- param []string
- paramFile string
- shared string // AKA "public" or "publish"
- skip int // skip first N records
- limit int // return max N records
- full bool // return full records (docs=true for client request)
- summary bool
- feed string // name of feed
- detail bool
- format string
- nameSort bool // sorts list alphabetically by entity name
- }
-
- property struct {
- cert bool
- key bool
- auth bool
- apihost bool
- apiversion bool
- namespace bool
- cliversion bool
- apibuild bool
- apibuildno bool
- insecure bool
- all bool
- apihostSet string
- apiversionSet string
- namespaceSet string
- }
-
- action ActionFlags
-
- activation struct {
- action string // retrieve results for this action
- upto int64 // retrieve results up to certain time
- since int64 // retrieve results after certain time
- seconds int // stop polling for activation upda
- sinceSeconds int
- sinceMinutes int
- sinceHours int
- sinceDays int
- exit int
- last bool
- strip bool
- }
-
- // rule
- rule struct {
- disable bool
- summary bool
- }
-
- // trigger
- trigger struct {
- summary bool
- }
-
- //sdk
- sdk struct {
- stdout bool
- }
-
- // api
- api struct {
- action string
- path string
- verb string
- basepath string
- apiname string
- configfile string
- resptype string
- }
+ Global struct {
+ Verbose bool
+ Debug bool
+ Cert string
+ Key string
+ Auth string
+ Apihost string
+ Apiversion string
+ Insecure bool
+ }
+
+ common struct {
+ blocking bool
+ annotation []string
+ annotFile string
+ param []string
+ paramFile string
+ shared string // AKA "public" or "publish"
+ skip int // skip first N records
+ limit int // return max N records
+ full bool // return full records (docs=true for client request)
+ summary bool
+ feed string // name of feed
+ detail bool
+ format string
+ nameSort bool // sorts list alphabetically by entity name
+ }
+
+ property struct {
+ cert bool
+ key bool
+ auth bool
+ apihost bool
+ apiversion bool
+ namespace bool
+ cliversion bool
+ apibuild bool
+ apibuildno bool
+ insecure bool
+ all bool
+ apihostSet string
+ apiversionSet string
+ namespaceSet string
+ }
+
+ action ActionFlags
+
+ activation struct {
+ action string // retrieve results for this action
+ upto int64 // retrieve results up to certain time
+ since int64 // retrieve results after certain time
+ seconds int // stop polling for activation upda
+ sinceSeconds int
+ sinceMinutes int
+ sinceHours int
+ sinceDays int
+ exit int
+ last bool
+ strip bool
+ }
+
+ // rule
+ rule struct {
+ disable bool
+ summary bool
+ }
+
+ // trigger
+ trigger struct {
+ summary bool
+ }
+
+ //sdk
+ sdk struct {
+ stdout bool
+ }
+
+ // api
+ api struct {
+ action string
+ path string
+ verb string
+ basepath string
+ apiname string
+ configfile string
+ resptype string
+ }
}
-
type ActionFlags struct {
- docker string
- native bool
- copy bool
- web string
- sequence bool
- timeout int
- memory int
- logsize int
- result bool
- kind string
- main string
- url bool
- save bool
- saveAs string
+ docker string
+ native bool
+ copy bool
+ web string
+ sequence bool
+ timeout int
+ memory int
+ logsize int
+ result bool
+ kind string
+ main string
+ url bool
+ save bool
+ saveAs string
}
func IsVerbose() bool {
- return Flags.Global.Verbose || IsDebug()
+ return Flags.Global.Verbose || IsDebug()
}
func IsDebug() bool {
- return len(cliDebug) > 0 || Flags.Global.Debug
+ return len(cliDebug) > 0 || Flags.Global.Debug
}
diff --git a/commands/namespace.go b/commands/namespace.go
index 6c1727b..15786b0 100644
--- a/commands/namespace.go
+++ b/commands/namespace.go
@@ -18,106 +18,114 @@
package commands
import (
- "fmt"
- "errors"
+ "errors"
+ "fmt"
- "github.com/spf13/cobra"
- "github.com/fatih/color"
+ "github.com/fatih/color"
+ "github.com/spf13/cobra"
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
)
// namespaceCmd represents the namespace command
var namespaceCmd = &cobra.Command{
- Use: "namespace",
- Short: wski18n.T("work with namespaces"),
+ Use: "namespace",
+ Short: wski18n.T("work with namespaces"),
}
var namespaceListCmd = &cobra.Command{
- Use: "list",
- Short: wski18n.T("list available namespaces"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- // add "TYPE" --> public / private
-
- if whiskErr := CheckArgs(args, 0, 0, "Namespace list", wski18n.T("No arguments are required.")); whiskErr != nil {
- return whiskErr
- }
-
- namespaces, _, err := Client.Namespaces.List()
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Namespaces.List() error: %s\n", err)
- errStr := wski18n.T("Unable to obtain the list of available namespaces: {{.err}}",
- map[string]interface{}{"err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- printList(namespaces, false) // `-n` flag applies to `namespace get`, not list, so must pass value false for printList here
- return nil
- },
+ Use: "list",
+ Short: wski18n.T("list available namespaces"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ // add "TYPE" --> public / private
+
+ if whiskErr := CheckArgs(args, 0, 0, "Namespace list", wski18n.T("No arguments are required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ namespaces, _, err := Client.Namespaces.List()
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Namespaces.List() error: %s\n", err)
+ errStr := wski18n.T("Unable to obtain the list of available namespaces: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ printList(namespaces, false) // `-n` flag applies to `namespace get`, not list, so must pass value false for printList here
+ return nil
+ },
}
var namespaceGetCmd = &cobra.Command{
- Use: "get",
- Short: wski18n.T("get triggers, actions, and rules in the registry for namespace"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var namespace string = getClientNamespace()
-
- if (!(len(args) == 1 && args[0] == "/_")) {
- if whiskErr := CheckArgs(args, 0, 0, "Namespace get",
- wski18n.T("No arguments are required.")); whiskErr != nil {
- return whiskErr
- }
- }
-
- actions, _, err := Client.Actions.List("", &whisk.ActionListOptions{ Skip: 0, Limit: 0 })
- if err != nil { return entityListError(err, namespace,"Actions") }
-
- packages, _, err := Client.Packages.List(&whisk.PackageListOptions{ Skip: 0, Limit: 0 })
- if err != nil { return entityListError(err, namespace,"Packages") }
-
- triggers, _, err := Client.Triggers.List(&whisk.TriggerListOptions{ Skip: 0, Limit: 0 })
- if err != nil { return entityListError(err, namespace,"Triggers") }
-
- rules, _, err := Client.Rules.List(&whisk.RuleListOptions{ Skip: 0, Limit: 0 })
- if err != nil { return entityListError(err, namespace,"Rules") }
- //No errors, lets attempt to retrieve the status of each rule
- for index, rule := range rules {
- ruleStatus, _, err := Client.Rules.Get(rule.Name)
- if err != nil {
- errStr := wski18n.T("Unable to get status of rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": rule.Name, "err": err})
- fmt.Println(errStr)
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- rules[index].Status = ruleStatus.Status
- }
-
- fmt.Fprintf(color.Output, wski18n.T("Entities in namespace: {{.namespace}}\n",
- map[string]interface{}{"namespace": boldString(getClientNamespace())}))
- sortByName := Flags.common.nameSort
- printList(packages, sortByName)
- printList(actions, sortByName)
- printList(triggers, sortByName)
- printList(rules, sortByName)
-
- return nil
- },
+ Use: "get",
+ Short: wski18n.T("get triggers, actions, and rules in the registry for namespace"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var namespace string = getClientNamespace()
+
+ if !(len(args) == 1 && args[0] == "/_") {
+ if whiskErr := CheckArgs(args, 0, 0, "Namespace get",
+ wski18n.T("No arguments are required.")); whiskErr != nil {
+ return whiskErr
+ }
+ }
+
+ actions, _, err := Client.Actions.List("", &whisk.ActionListOptions{Skip: 0, Limit: 0})
+ if err != nil {
+ return entityListError(err, namespace, "Actions")
+ }
+
+ packages, _, err := Client.Packages.List(&whisk.PackageListOptions{Skip: 0, Limit: 0})
+ if err != nil {
+ return entityListError(err, namespace, "Packages")
+ }
+
+ triggers, _, err := Client.Triggers.List(&whisk.TriggerListOptions{Skip: 0, Limit: 0})
+ if err != nil {
+ return entityListError(err, namespace, "Triggers")
+ }
+
+ rules, _, err := Client.Rules.List(&whisk.RuleListOptions{Skip: 0, Limit: 0})
+ if err != nil {
+ return entityListError(err, namespace, "Rules")
+ }
+ //No errors, lets attempt to retrieve the status of each rule
+ for index, rule := range rules {
+ ruleStatus, _, err := Client.Rules.Get(rule.Name)
+ if err != nil {
+ errStr := wski18n.T("Unable to get status of rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": rule.Name, "err": err})
+ fmt.Println(errStr)
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ rules[index].Status = ruleStatus.Status
+ }
+
+ fmt.Fprintf(color.Output, wski18n.T("Entities in namespace: {{.namespace}}\n",
+ map[string]interface{}{"namespace": boldString(getClientNamespace())}))
+ sortByName := Flags.common.nameSort
+ printList(packages, sortByName)
+ printList(actions, sortByName)
+ printList(triggers, sortByName)
+ printList(rules, sortByName)
+
+ return nil
+ },
}
func init() {
- namespaceGetCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by entity name; only applicable within the limit/skip returned entity block"))
+ namespaceGetCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by entity name; only applicable within the limit/skip returned entity block"))
- namespaceCmd.AddCommand(
- namespaceListCmd,
- namespaceGetCmd,
- )
+ namespaceCmd.AddCommand(
+ namespaceListCmd,
+ namespaceGetCmd,
+ )
}
diff --git a/commands/package.go b/commands/package.go
index c83ee53..1f62c93 100644
--- a/commands/package.go
+++ b/commands/package.go
@@ -18,522 +18,522 @@
package commands
import (
- "errors"
- "fmt"
- "net/http"
+ "errors"
+ "fmt"
+ "net/http"
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/fatih/color"
- "github.com/spf13/cobra"
+ "github.com/fatih/color"
+ "github.com/spf13/cobra"
)
var packageCmd = &cobra.Command{
- Use: "package",
- Short: wski18n.T("work with packages"),
+ Use: "package",
+ Short: wski18n.T("work with packages"),
}
var packageBindCmd = &cobra.Command{
- Use: "bind PACKAGE_NAME BOUND_PACKAGE_NAME",
- Short: wski18n.T("bind parameters to a package"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var pkgQualifiedName = new(QualifiedName)
- var bindQualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 2, 2, "Package bind",
- wski18n.T("A package name and binding name are required.")); whiskErr != nil {
- return whiskErr
- }
-
- packageName := args[0]
- if pkgQualifiedName, err = NewQualifiedName(packageName); err != nil {
- return NewQualifiedNameError(packageName, err)
- }
-
- bindingName := args[1]
- if bindQualifiedName, err = NewQualifiedName(bindingName); err != nil {
- return NewQualifiedNameError(bindingName, err)
- }
-
- Client.Namespace = bindQualifiedName.GetNamespace()
-
- // Convert the binding's list of default parameters from a string into []KeyValue
- // The 1 or more --param arguments have all been combined into a single []string
- // e.g. --p arg1,arg2 --p arg3,arg4 -> [arg1, arg2, arg3, arg4]
-
- whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
- parameters, err := getJSONFromStrings(Flags.common.param, true)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
- errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
- map[string]interface{}{"param": fmt.Sprintf("%#v",Flags.common.param), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- // Convert the binding's list of default annotations from a string into []KeyValue
- // The 1 or more --annotation arguments have all been combined into a single []string
- // e.g. --a arg1,arg2 --a arg3,arg4 -> [arg1, arg2, arg3, arg4]
- whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
- annotations, err := getJSONFromStrings(Flags.common.annotation, true)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
- errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
- map[string]interface{}{"annotation": fmt.Sprintf("%#v",Flags.common.annotation), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- binding := whisk.Binding{
- Name: pkgQualifiedName.GetEntityName(),
- Namespace: pkgQualifiedName.GetNamespace(),
- }
-
- p := &whisk.BindingPackage{
- Name: bindQualifiedName.GetEntityName(),
- Annotations: annotations.(whisk.KeyValueArr),
- Parameters: parameters.(whisk.KeyValueArr),
- Binding: binding,
- }
-
- _, _, err = Client.Packages.Insert(p, false)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Packages.Insert(%#v, false) failed: %s\n", p, err)
- errStr := wski18n.T("Binding creation failed: {{.err}}", map[string]interface{}{"err":err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} created binding {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString(wski18n.T("ok:")), "name":boldString(bindingName)}))
- return nil
- },
+ Use: "bind PACKAGE_NAME BOUND_PACKAGE_NAME",
+ Short: wski18n.T("bind parameters to a package"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var pkgQualifiedName = new(QualifiedName)
+ var bindQualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 2, 2, "Package bind",
+ wski18n.T("A package name and binding name are required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ packageName := args[0]
+ if pkgQualifiedName, err = NewQualifiedName(packageName); err != nil {
+ return NewQualifiedNameError(packageName, err)
+ }
+
+ bindingName := args[1]
+ if bindQualifiedName, err = NewQualifiedName(bindingName); err != nil {
+ return NewQualifiedNameError(bindingName, err)
+ }
+
+ Client.Namespace = bindQualifiedName.GetNamespace()
+
+ // Convert the binding's list of default parameters from a string into []KeyValue
+ // The 1 or more --param arguments have all been combined into a single []string
+ // e.g. --p arg1,arg2 --p arg3,arg4 -> [arg1, arg2, arg3, arg4]
+
+ whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
+ parameters, err := getJSONFromStrings(Flags.common.param, true)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
+ errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
+ map[string]interface{}{"param": fmt.Sprintf("%#v", Flags.common.param), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ // Convert the binding's list of default annotations from a string into []KeyValue
+ // The 1 or more --annotation arguments have all been combined into a single []string
+ // e.g. --a arg1,arg2 --a arg3,arg4 -> [arg1, arg2, arg3, arg4]
+ whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
+ annotations, err := getJSONFromStrings(Flags.common.annotation, true)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
+ errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
+ map[string]interface{}{"annotation": fmt.Sprintf("%#v", Flags.common.annotation), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ binding := whisk.Binding{
+ Name: pkgQualifiedName.GetEntityName(),
+ Namespace: pkgQualifiedName.GetNamespace(),
+ }
+
+ p := &whisk.BindingPackage{
+ Name: bindQualifiedName.GetEntityName(),
+ Annotations: annotations.(whisk.KeyValueArr),
+ Parameters: parameters.(whisk.KeyValueArr),
+ Binding: binding,
+ }
+
+ _, _, err = Client.Packages.Insert(p, false)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Packages.Insert(%#v, false) failed: %s\n", p, err)
+ errStr := wski18n.T("Binding creation failed: {{.err}}", map[string]interface{}{"err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} created binding {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString(wski18n.T("ok:")), "name": boldString(bindingName)}))
+ return nil
+ },
}
var packageCreateCmd = &cobra.Command{
- Use: "create PACKAGE_NAME",
- Short: wski18n.T("create a new package"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var shared, sharedSet bool
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Package create", wski18n.T("A package name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- if shared, sharedSet, err = parseShared(Flags.common.shared); err != nil {
- whisk.Debug(whisk.DbgError, "parseShared(%s) failed: %s\n", Flags.common.shared, err)
- return err
- }
-
- whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
- parameters, err := getJSONFromStrings(Flags.common.param, true)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
- errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
- map[string]interface{}{"param": fmt.Sprintf("%#v",Flags.common.param), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
- annotations, err := getJSONFromStrings(Flags.common.annotation, true)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
- errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
- map[string]interface{}{"annotation": fmt.Sprintf("%#v",Flags.common.annotation), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- p := &whisk.Package{
- Name: qualifiedName.GetEntityName(),
- Namespace: qualifiedName.GetNamespace(),
- Annotations: annotations.(whisk.KeyValueArr),
- Parameters: parameters.(whisk.KeyValueArr),
- }
-
- if sharedSet {
- p.Publish = &shared
- }
-
- p, _, err = Client.Packages.Insert(p, false)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Packages.Insert(%#v, false) failed: %s\n", p, err)
- errStr := wski18n.T(
- "Unable to create package '{{.name}}': {{.err}}",
- map[string]interface{}{
- "name": qualifiedName.GetEntityName(),
- "err": err,
- })
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} created package {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString(wski18n.T("ok:")), "name":boldString(qualifiedName.GetEntityName())}))
- return nil
- },
+ Use: "create PACKAGE_NAME",
+ Short: wski18n.T("create a new package"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var shared, sharedSet bool
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Package create", wski18n.T("A package name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ if shared, sharedSet, err = parseShared(Flags.common.shared); err != nil {
+ whisk.Debug(whisk.DbgError, "parseShared(%s) failed: %s\n", Flags.common.shared, err)
+ return err
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
+ parameters, err := getJSONFromStrings(Flags.common.param, true)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
+ errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
+ map[string]interface{}{"param": fmt.Sprintf("%#v", Flags.common.param), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
+ annotations, err := getJSONFromStrings(Flags.common.annotation, true)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
+ errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
+ map[string]interface{}{"annotation": fmt.Sprintf("%#v", Flags.common.annotation), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ p := &whisk.Package{
+ Name: qualifiedName.GetEntityName(),
+ Namespace: qualifiedName.GetNamespace(),
+ Annotations: annotations.(whisk.KeyValueArr),
+ Parameters: parameters.(whisk.KeyValueArr),
+ }
+
+ if sharedSet {
+ p.Publish = &shared
+ }
+
+ p, _, err = Client.Packages.Insert(p, false)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Packages.Insert(%#v, false) failed: %s\n", p, err)
+ errStr := wski18n.T(
+ "Unable to create package '{{.name}}': {{.err}}",
+ map[string]interface{}{
+ "name": qualifiedName.GetEntityName(),
+ "err": err,
+ })
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} created package {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString(wski18n.T("ok:")), "name": boldString(qualifiedName.GetEntityName())}))
+ return nil
+ },
}
var packageUpdateCmd = &cobra.Command{
- Use: "update PACKAGE_NAME",
- Short: wski18n.T("update an existing package, or create a package if it does not exist"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var shared, sharedSet bool
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Package update", wski18n.T("A package name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- if shared, sharedSet, err = parseShared(Flags.common.shared); err != nil {
- whisk.Debug(whisk.DbgError, "parseShared(%s) failed: %s\n", Flags.common.shared, err)
- return err
- }
-
- whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
- parameters, err := getJSONFromStrings(Flags.common.param, true)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
- errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
- map[string]interface{}{"param": fmt.Sprintf("%#v",Flags.common.param), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
- annotations, err := getJSONFromStrings(Flags.common.annotation, true)
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
- errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
- map[string]interface{}{"annotation": fmt.Sprintf("%#v",Flags.common.annotation), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- p := &whisk.Package{
- Name: qualifiedName.GetEntityName(),
- Namespace: qualifiedName.GetNamespace(),
- Annotations: annotations.(whisk.KeyValueArr),
- Parameters: parameters.(whisk.KeyValueArr),
- }
-
- if sharedSet {
- p.Publish = &shared
- }
-
- p, _, err = Client.Packages.Insert(p, true)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Packages.Insert(%#v, true) failed: %s\n", p, err)
- errStr := wski18n.T("Package update failed: {{.err}}", map[string]interface{}{"err":err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} updated package {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString(wski18n.T("ok:")), "name":boldString(qualifiedName.GetEntityName())}))
- return nil
- },
+ Use: "update PACKAGE_NAME",
+ Short: wski18n.T("update an existing package, or create a package if it does not exist"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var shared, sharedSet bool
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Package update", wski18n.T("A package name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ if shared, sharedSet, err = parseShared(Flags.common.shared); err != nil {
+ whisk.Debug(whisk.DbgError, "parseShared(%s) failed: %s\n", Flags.common.shared, err)
+ return err
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
+ parameters, err := getJSONFromStrings(Flags.common.param, true)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
+ errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
+ map[string]interface{}{"param": fmt.Sprintf("%#v", Flags.common.param), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
+ annotations, err := getJSONFromStrings(Flags.common.annotation, true)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
+ errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
+ map[string]interface{}{"annotation": fmt.Sprintf("%#v", Flags.common.annotation), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ p := &whisk.Package{
+ Name: qualifiedName.GetEntityName(),
+ Namespace: qualifiedName.GetNamespace(),
+ Annotations: annotations.(whisk.KeyValueArr),
+ Parameters: parameters.(whisk.KeyValueArr),
+ }
+
+ if sharedSet {
+ p.Publish = &shared
+ }
+
+ p, _, err = Client.Packages.Insert(p, true)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Packages.Insert(%#v, true) failed: %s\n", p, err)
+ errStr := wski18n.T("Package update failed: {{.err}}", map[string]interface{}{"err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} updated package {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString(wski18n.T("ok:")), "name": boldString(qualifiedName.GetEntityName())}))
+ return nil
+ },
}
var packageGetCmd = &cobra.Command{
- Use: "get PACKAGE_NAME [FIELD_FILTER]",
- Short: wski18n.T("get package"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var field string
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 2, "Package get", wski18n.T("A package name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if len(args) > 1 {
- field = args[1]
-
- if !fieldExists(&whisk.Package{}, field) {
- errMsg := wski18n.T("Invalid field filter '{{.arg}}'.", map[string]interface{}{"arg": field})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
- Client.Namespace = qualifiedName.GetNamespace()
-
- xPackage, _, err := Client.Packages.Get(qualifiedName.GetEntityName())
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Packages.Get(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
- errStr := wski18n.T(
- "Unable to get package '{{.name}}': {{.err}}",
- map[string]interface{}{
- "name": qualifiedName.GetEntityName(),
- "err":err,
- })
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- if Flags.common.summary {
- printSummary(xPackage)
- } else {
-
- if len(field) > 0 {
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got package {{.name}}, displaying field {{.field}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName()),
- "field": boldString(field)}))
- printField(xPackage, field)
- } else {
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got package {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
- printJSON(xPackage)
- }
- }
-
- return nil
- },
+ Use: "get PACKAGE_NAME [FIELD_FILTER]",
+ Short: wski18n.T("get package"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var field string
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 2, "Package get", wski18n.T("A package name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if len(args) > 1 {
+ field = args[1]
+
+ if !fieldExists(&whisk.Package{}, field) {
+ errMsg := wski18n.T("Invalid field filter '{{.arg}}'.", map[string]interface{}{"arg": field})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ xPackage, _, err := Client.Packages.Get(qualifiedName.GetEntityName())
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Packages.Get(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
+ errStr := wski18n.T(
+ "Unable to get package '{{.name}}': {{.err}}",
+ map[string]interface{}{
+ "name": qualifiedName.GetEntityName(),
+ "err": err,
+ })
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ if Flags.common.summary {
+ printSummary(xPackage)
+ } else {
+
+ if len(field) > 0 {
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got package {{.name}}, displaying field {{.field}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName()),
+ "field": boldString(field)}))
+ printField(xPackage, field)
+ } else {
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got package {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
+ printJSON(xPackage)
+ }
+ }
+
+ return nil
+ },
}
var packageDeleteCmd = &cobra.Command{
- Use: "delete PACKAGE_NAME",
- Short: wski18n.T("delete package"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Package delete", wski18n.T("A package name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- _, err = Client.Packages.Delete(qualifiedName.GetEntityName())
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Packages.Delete(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
- errStr := wski18n.T(
- "Unable to delete package '{{.name}}': {{.err}}",
- map[string]interface{}{
- "name": qualifiedName.GetEntityName(),
- "err": err,
- })
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} deleted package {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
- return nil
- },
+ Use: "delete PACKAGE_NAME",
+ Short: wski18n.T("delete package"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Package delete", wski18n.T("A package name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ _, err = Client.Packages.Delete(qualifiedName.GetEntityName())
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Packages.Delete(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
+ errStr := wski18n.T(
+ "Unable to delete package '{{.name}}': {{.err}}",
+ map[string]interface{}{
+ "name": qualifiedName.GetEntityName(),
+ "err": err,
+ })
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} deleted package {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
+ return nil
+ },
}
var packageListCmd = &cobra.Command{
- Use: "list [NAMESPACE]",
- Short: wski18n.T("list all packages"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 0, 1, "Package list",
- wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
- return whiskErr
- }
-
- if len(args) == 1 {
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- if len(qualifiedName.GetEntityName()) > 0 {
- return entityNameError(qualifiedName.GetEntityName())
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- }
-
- options := &whisk.PackageListOptions{
- Skip: Flags.common.skip,
- Limit: Flags.common.limit,
- }
-
- packages, _, err := Client.Packages.List(options)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Packages.List(%+v) failed: %s\n", options, err)
- errStr := wski18n.T("Unable to obtain the list of packages for namespace '{{.name}}': {{.err}}",
- map[string]interface{}{"name": getClientNamespace(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- sortByName := Flags.common.nameSort
- printList(packages, sortByName)
-
- return nil
- },
+ Use: "list [NAMESPACE]",
+ Short: wski18n.T("list all packages"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 0, 1, "Package list",
+ wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if len(args) == 1 {
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ if len(qualifiedName.GetEntityName()) > 0 {
+ return entityNameError(qualifiedName.GetEntityName())
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ }
+
+ options := &whisk.PackageListOptions{
+ Skip: Flags.common.skip,
+ Limit: Flags.common.limit,
+ }
+
+ packages, _, err := Client.Packages.List(options)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Packages.List(%+v) failed: %s\n", options, err)
+ errStr := wski18n.T("Unable to obtain the list of packages for namespace '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": getClientNamespace(), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ sortByName := Flags.common.nameSort
+ printList(packages, sortByName)
+
+ return nil
+ },
}
var packageRefreshCmd = &cobra.Command{
- Use: "refresh [NAMESPACE]",
- Short: wski18n.T("refresh package bindings"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 0, 1, "Package refresh",
- wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
- return whiskErr
- }
-
- if len(args) == 0 {
- qualifiedName.namespace = getNamespaceFromProp()
- } else {
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- if len(qualifiedName.GetEntityName()) > 0 {
- return entityNameError(qualifiedName.GetEntityName())
- }
- }
-
- currentNamespace := Client.Config.Namespace
- Client.Config.Namespace = qualifiedName.GetNamespace()
-
- defer func() {
- Client.Config.Namespace = currentNamespace
- }()
-
- updates, resp, err := Client.Packages.Refresh()
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Packages.Refresh() of namespace '%s' failed: %s\n", Client.Config.Namespace, err)
- errStr := wski18n.T("Package refresh for namespace '{{.name}}' failed: {{.err}}",
- map[string]interface{}{"name": Client.Config.Namespace, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- whisk.Debug(whisk.DbgInfo, "Refresh updates received: %#v\n", updates)
-
- switch resp.StatusCode {
- case http.StatusOK:
- fmt.Printf(wski18n.T("'{{.name}}' refreshed successfully\n",
- map[string]interface{}{"name": Client.Config.Namespace}))
-
- fmt.Println(wski18n.T("created bindings:"))
-
- if len(updates.Added) > 0 {
- printArrayContents(updates.Added)
- }
-
- fmt.Println(wski18n.T("updated bindings:"))
-
- if len(updates.Updated) > 0 {
- printArrayContents(updates.Updated)
- }
-
- fmt.Println(wski18n.T("deleted bindings:"))
-
- if len(updates.Deleted) > 0 {
- printArrayContents(updates.Deleted)
- }
-
- case http.StatusNotImplemented:
- whisk.Debug(whisk.DbgError, "Client.Packages.Refresh() for namespace '%s' returned 'Not Implemented' HTTP status code: %d\n", Client.Config.Namespace, resp.StatusCode)
- errStr := wski18n.T("The package refresh feature is not implemented in the target deployment")
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- default:
- whisk.Debug(whisk.DbgError, "Client.Packages.Refresh() for namespace '%s' returned an unexpected HTTP status code: %d\n", Client.Config.Namespace, resp.StatusCode)
- errStr := wski18n.T("Package refresh for namespace '{{.name}}' failed due to unexpected HTTP status code: {{.code}}",
- map[string]interface{}{"name": Client.Config.Namespace, "code": resp.StatusCode})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- return nil
- },
+ Use: "refresh [NAMESPACE]",
+ Short: wski18n.T("refresh package bindings"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 0, 1, "Package refresh",
+ wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if len(args) == 0 {
+ qualifiedName.namespace = getNamespaceFromProp()
+ } else {
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ if len(qualifiedName.GetEntityName()) > 0 {
+ return entityNameError(qualifiedName.GetEntityName())
+ }
+ }
+
+ currentNamespace := Client.Config.Namespace
+ Client.Config.Namespace = qualifiedName.GetNamespace()
+
+ defer func() {
+ Client.Config.Namespace = currentNamespace
+ }()
+
+ updates, resp, err := Client.Packages.Refresh()
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Packages.Refresh() of namespace '%s' failed: %s\n", Client.Config.Namespace, err)
+ errStr := wski18n.T("Package refresh for namespace '{{.name}}' failed: {{.err}}",
+ map[string]interface{}{"name": Client.Config.Namespace, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ whisk.Debug(whisk.DbgInfo, "Refresh updates received: %#v\n", updates)
+
+ switch resp.StatusCode {
+ case http.StatusOK:
+ fmt.Printf(wski18n.T("'{{.name}}' refreshed successfully\n",
+ map[string]interface{}{"name": Client.Config.Namespace}))
+
+ fmt.Println(wski18n.T("created bindings:"))
+
+ if len(updates.Added) > 0 {
+ printArrayContents(updates.Added)
+ }
+
+ fmt.Println(wski18n.T("updated bindings:"))
+
+ if len(updates.Updated) > 0 {
+ printArrayContents(updates.Updated)
+ }
+
+ fmt.Println(wski18n.T("deleted bindings:"))
+
+ if len(updates.Deleted) > 0 {
+ printArrayContents(updates.Deleted)
+ }
+
+ case http.StatusNotImplemented:
+ whisk.Debug(whisk.DbgError, "Client.Packages.Refresh() for namespace '%s' returned 'Not Implemented' HTTP status code: %d\n", Client.Config.Namespace, resp.StatusCode)
+ errStr := wski18n.T("The package refresh feature is not implemented in the target deployment")
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ default:
+ whisk.Debug(whisk.DbgError, "Client.Packages.Refresh() for namespace '%s' returned an unexpected HTTP status code: %d\n", Client.Config.Namespace, resp.StatusCode)
+ errStr := wski18n.T("Package refresh for namespace '{{.name}}' failed due to unexpected HTTP status code: {{.code}}",
+ map[string]interface{}{"name": Client.Config.Namespace, "code": resp.StatusCode})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ return nil
+ },
}
func init() {
- packageCreateCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", []string{}, wski18n.T("annotation values in `KEY VALUE` format"))
- packageCreateCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
- packageCreateCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
- packageCreateCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
- packageCreateCmd.Flags().StringVar(&Flags.common.shared, "shared", "", wski18n.T("package visibility `SCOPE`; yes = shared, no = private"))
-
- packageUpdateCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", []string{}, wski18n.T("annotation values in `KEY VALUE` format"))
- packageUpdateCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
- packageUpdateCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
- packageUpdateCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
- packageUpdateCmd.Flags().StringVar(&Flags.common.shared, "shared", "", wski18n.T("package visibility `SCOPE`; yes = shared, no = private"))
-
- packageGetCmd.Flags().BoolVarP(&Flags.common.summary, "summary", "s", false, wski18n.T("summarize package details; parameters with prefix \"*\" are bound"))
-
- packageBindCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", []string{}, wski18n.T("annotation values in `KEY VALUE` format"))
- packageBindCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
- packageBindCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
- packageBindCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
-
- packageListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of packages from the result"))
- packageListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", 30, wski18n.T("only return `LIMIT` number of packages from the collection"))
- packageListCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by entity name; only applicable within the limit/skip returned entity block"))
-
- packageCmd.AddCommand(
- packageBindCmd,
- packageCreateCmd,
- packageUpdateCmd,
- packageGetCmd,
- packageDeleteCmd,
- packageListCmd,
- packageRefreshCmd,
- )
+ packageCreateCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", []string{}, wski18n.T("annotation values in `KEY VALUE` format"))
+ packageCreateCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
+ packageCreateCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
+ packageCreateCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
+ packageCreateCmd.Flags().StringVar(&Flags.common.shared, "shared", "", wski18n.T("package visibility `SCOPE`; yes = shared, no = private"))
+
+ packageUpdateCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", []string{}, wski18n.T("annotation values in `KEY VALUE` format"))
+ packageUpdateCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
+ packageUpdateCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
+ packageUpdateCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
+ packageUpdateCmd.Flags().StringVar(&Flags.common.shared, "shared", "", wski18n.T("package visibility `SCOPE`; yes = shared, no = private"))
+
+ packageGetCmd.Flags().BoolVarP(&Flags.common.summary, "summary", "s", false, wski18n.T("summarize package details; parameters with prefix \"*\" are bound"))
+
+ packageBindCmd.Flags().StringSliceVarP(&Flags.common.annotation, "annotation", "a", []string{}, wski18n.T("annotation values in `KEY VALUE` format"))
+ packageBindCmd.Flags().StringVarP(&Flags.common.annotFile, "annotation-file", "A", "", wski18n.T("`FILE` containing annotation values in JSON format"))
+ packageBindCmd.Flags().StringSliceVarP(&Flags.common.param, "param", "p", []string{}, wski18n.T("parameter values in `KEY VALUE` format"))
+ packageBindCmd.Flags().StringVarP(&Flags.common.paramFile, "param-file", "P", "", wski18n.T("`FILE` containing parameter values in JSON format"))
+
+ packageListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of packages from the result"))
+ packageListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", 30, wski18n.T("only return `LIMIT` number of packages from the collection"))
+ packageListCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by entity name; only applicable within the limit/skip returned entity block"))
+
+ packageCmd.AddCommand(
+ packageBindCmd,
+ packageCreateCmd,
+ packageUpdateCmd,
+ packageGetCmd,
+ packageDeleteCmd,
+ packageListCmd,
+ packageRefreshCmd,
+ )
}
diff --git a/commands/property.go b/commands/property.go
index 38afa43..84230bf 100644
--- a/commands/property.go
+++ b/commands/property.go
@@ -18,543 +18,543 @@
package commands
import (
- "errors"
- "fmt"
- "os"
+ "errors"
+ "fmt"
+ "os"
- "github.com/mitchellh/go-homedir"
- "github.com/spf13/cobra"
- "github.com/fatih/color"
+ "github.com/fatih/color"
+ "github.com/mitchellh/go-homedir"
+ "github.com/spf13/cobra"
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
)
var Properties struct {
- Cert string
- Key string
- Auth string
- APIHost string
- APIVersion string
- APIBuild string
- APIBuildNo string
- CLIVersion string
- Namespace string
- PropsFile string
+ Cert string
+ Key string
+ Auth string
+ APIHost string
+ APIVersion string
+ APIBuild string
+ APIBuildNo string
+ CLIVersion string
+ Namespace string
+ PropsFile string
}
-const DefaultCert string = ""
-const DefaultKey string = ""
-const DefaultAuth string = ""
-const DefaultAPIHost string = ""
+const DefaultCert string = ""
+const DefaultKey string = ""
+const DefaultAuth string = ""
+const DefaultAPIHost string = ""
const DefaultAPIVersion string = "v1"
-const DefaultAPIBuild string = ""
+const DefaultAPIBuild string = ""
const DefaultAPIBuildNo string = ""
-const DefaultNamespace string = "_"
-const DefaultPropsFile string = "~/.wskprops"
+const DefaultNamespace string = "_"
+const DefaultPropsFile string = "~/.wskprops"
var propertyCmd = &cobra.Command{
- Use: "property",
- Short: wski18n.T("work with whisk properties"),
+ Use: "property",
+ Short: wski18n.T("work with whisk properties"),
}
//
// Set one or more openwhisk property values
//
var propertySetCmd = &cobra.Command{
- Use: "set",
- Short: wski18n.T("set property"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var okMsg string = ""
- var werr *whisk.WskError = nil
-
- // get current props
- props, err := ReadProps(Properties.PropsFile)
- if err != nil {
- whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
- errStr := wski18n.T("Unable to set the property value: {{.err}}", map[string]interface{}{"err": err})
- werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- // read in each flag, update if necessary
- if cert := Flags.Global.Cert; len(cert) > 0 {
- props["CERT"] = cert
- Client.Config.Cert = cert
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} client cert set. Run 'wsk property get --cert' to see the new value.\n",
- map[string]interface{}{"ok": color.GreenString("ok:")}))
- }
-
- if key := Flags.Global.Key; len(key) > 0 {
- props["KEY"] = key
- Client.Config.Key = key
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} client key set. Run 'wsk property get --key' to see the new value.\n",
- map[string]interface{}{"ok": color.GreenString("ok:")}))
- }
-
- if auth := Flags.Global.Auth; len(auth) > 0 {
- props["AUTH"] = auth
- Client.Config.AuthToken = auth
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} whisk auth set. Run 'wsk property get --auth' to see the new value.\n",
- map[string]interface{}{"ok": color.GreenString("ok:")}))
- }
-
- if apiHost := Flags.property.apihostSet; len(apiHost) > 0 {
- baseURL, err := whisk.GetURLBase(apiHost, DefaultOpenWhiskApiPath)
-
- if err != nil {
- // Not aborting now. Subsequent commands will result in error
- whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) error: %s", apiHost, DefaultOpenWhiskApiPath, err)
- errStr := fmt.Sprintf(
- wski18n.T("Unable to set API host value; the API host value '{{.apihost}}' is invalid: {{.err}}",
- map[string]interface{}{"apihost": apiHost, "err": err}))
- werr = whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- } else {
- props["APIHOST"] = apiHost
- Client.Config.BaseURL = baseURL
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} whisk API host set to {{.host}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "host": boldString(apiHost)}))
- }
- }
-
- if apiVersion := Flags.property.apiversionSet; len(apiVersion) > 0 {
- props["APIVERSION"] = apiVersion
- Client.Config.Version = apiVersion
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} whisk API version set to {{.version}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "version": boldString(apiVersion)}))
- }
-
- if namespace := Flags.property.namespaceSet; len(namespace) > 0 {
- namespaces, _, err := Client.Namespaces.List()
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Namespaces.List() failed: %s\n", err)
- errStr := fmt.Sprintf(
- wski18n.T("Authenticated user does not have namespace '{{.name}}'; set command failed: {{.err}}",
- map[string]interface{}{"name": namespace, "err": err}))
- werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- } else {
- whisk.Debug(whisk.DbgInfo, "Validating namespace '%s' is in user namespace list %#v\n", namespace, namespaces)
- var validNamespace bool
- for _, ns := range namespaces {
- if ns.Name == namespace {
- whisk.Debug(whisk.DbgInfo, "Namespace '%s' is valid\n", namespace)
- validNamespace = true
- }
- }
- if !validNamespace {
- whisk.Debug(whisk.DbgError, "Namespace '%s' is not in the list of entitled namespaces\n", namespace)
- errStr := fmt.Sprintf(
- wski18n.T("Namespace '{{.name}}' is not in the list of entitled namespaces",
- map[string]interface{}{"name": namespace}))
- werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- } else {
- props["NAMESPACE"] = namespace
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} whisk namespace set to {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(namespace)}))
- }
- }
- }
-
- err = WriteProps(Properties.PropsFile, props)
- if err != nil {
- whisk.Debug(whisk.DbgError, "writeProps(%s, %#v) failed: %s\n", Properties.PropsFile, props, err)
- errStr := fmt.Sprintf(
- wski18n.T("Unable to set the property value(s): {{.err}}",
- map[string]interface{}{"err": err}))
- werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- } else {
- fmt.Fprintf(color.Output, okMsg)
- }
-
- if (werr != nil) {
- return werr
- }
-
- return nil
- },
+ Use: "set",
+ Short: wski18n.T("set property"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var okMsg string = ""
+ var werr *whisk.WskError = nil
+
+ // get current props
+ props, err := ReadProps(Properties.PropsFile)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
+ errStr := wski18n.T("Unable to set the property value: {{.err}}", map[string]interface{}{"err": err})
+ werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ // read in each flag, update if necessary
+ if cert := Flags.Global.Cert; len(cert) > 0 {
+ props["CERT"] = cert
+ Client.Config.Cert = cert
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} client cert set. Run 'wsk property get --cert' to see the new value.\n",
+ map[string]interface{}{"ok": color.GreenString("ok:")}))
+ }
+
+ if key := Flags.Global.Key; len(key) > 0 {
+ props["KEY"] = key
+ Client.Config.Key = key
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} client key set. Run 'wsk property get --key' to see the new value.\n",
+ map[string]interface{}{"ok": color.GreenString("ok:")}))
+ }
+
+ if auth := Flags.Global.Auth; len(auth) > 0 {
+ props["AUTH"] = auth
+ Client.Config.AuthToken = auth
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} whisk auth set. Run 'wsk property get --auth' to see the new value.\n",
+ map[string]interface{}{"ok": color.GreenString("ok:")}))
+ }
+
+ if apiHost := Flags.property.apihostSet; len(apiHost) > 0 {
+ baseURL, err := whisk.GetURLBase(apiHost, DefaultOpenWhiskApiPath)
+
+ if err != nil {
+ // Not aborting now. Subsequent commands will result in error
+ whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) error: %s", apiHost, DefaultOpenWhiskApiPath, err)
+ errStr := fmt.Sprintf(
+ wski18n.T("Unable to set API host value; the API host value '{{.apihost}}' is invalid: {{.err}}",
+ map[string]interface{}{"apihost": apiHost, "err": err}))
+ werr = whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ } else {
+ props["APIHOST"] = apiHost
+ Client.Config.BaseURL = baseURL
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} whisk API host set to {{.host}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "host": boldString(apiHost)}))
+ }
+ }
+
+ if apiVersion := Flags.property.apiversionSet; len(apiVersion) > 0 {
+ props["APIVERSION"] = apiVersion
+ Client.Config.Version = apiVersion
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} whisk API version set to {{.version}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "version": boldString(apiVersion)}))
+ }
+
+ if namespace := Flags.property.namespaceSet; len(namespace) > 0 {
+ namespaces, _, err := Client.Namespaces.List()
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Namespaces.List() failed: %s\n", err)
+ errStr := fmt.Sprintf(
+ wski18n.T("Authenticated user does not have namespace '{{.name}}'; set command failed: {{.err}}",
+ map[string]interface{}{"name": namespace, "err": err}))
+ werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ } else {
+ whisk.Debug(whisk.DbgInfo, "Validating namespace '%s' is in user namespace list %#v\n", namespace, namespaces)
+ var validNamespace bool
+ for _, ns := range namespaces {
+ if ns.Name == namespace {
+ whisk.Debug(whisk.DbgInfo, "Namespace '%s' is valid\n", namespace)
+ validNamespace = true
+ }
+ }
+ if !validNamespace {
+ whisk.Debug(whisk.DbgError, "Namespace '%s' is not in the list of entitled namespaces\n", namespace)
+ errStr := fmt.Sprintf(
+ wski18n.T("Namespace '{{.name}}' is not in the list of entitled namespaces",
+ map[string]interface{}{"name": namespace}))
+ werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ } else {
+ props["NAMESPACE"] = namespace
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} whisk namespace set to {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(namespace)}))
+ }
+ }
+ }
+
+ err = WriteProps(Properties.PropsFile, props)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "writeProps(%s, %#v) failed: %s\n", Properties.PropsFile, props, err)
+ errStr := fmt.Sprintf(
+ wski18n.T("Unable to set the property value(s): {{.err}}",
+ map[string]interface{}{"err": err}))
+ werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ } else {
+ fmt.Fprintf(color.Output, okMsg)
+ }
+
+ if werr != nil {
+ return werr
+ }
+
+ return nil
+ },
}
var propertyUnsetCmd = &cobra.Command{
- Use: "unset",
- Short: wski18n.T("unset property"),
- SilenceUsage: true,
- SilenceErrors: true,
- RunE: func(cmd *cobra.Command, args []string) error {
- var okMsg string = ""
- props, err := ReadProps(Properties.PropsFile)
- if err != nil {
- whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
- errStr := fmt.Sprintf(
- wski18n.T("Unable to unset the property value: {{.err}}",
- map[string]interface{}{"err": err}))
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- // read in each flag, update if necessary
-
- if Flags.property.cert {
- delete(props, "CERT")
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} client cert unset.\n",
- map[string]interface{}{"ok": color.GreenString("ok:")}))
- }
-
- if Flags.property.key {
- delete(props, "KEY")
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} client key unset.\n",
- map[string]interface{}{"ok": color.GreenString("ok:")}))
- }
-
- if Flags.property.auth {
- delete(props, "AUTH")
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} whisk auth unset.\n",
- map[string]interface{}{"ok": color.GreenString("ok:")}))
- }
-
- if Flags.property.namespace {
- delete(props, "NAMESPACE")
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} whisk namespace unset",
- map[string]interface{}{"ok": color.GreenString("ok:")}))
- if len(DefaultNamespace) > 0 {
- okMsg += fmt.Sprintf(
- wski18n.T("; the default value of {{.default}} will be used.\n",
- map[string]interface{}{"default": boldString(DefaultNamespace)}))
- } else {
- okMsg += fmt.Sprint(
- wski18n.T("; there is no default value that can be used.\n"))
- }
- }
-
- if Flags.property.apihost {
- delete(props, "APIHOST")
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} whisk API host unset.\n",
- map[string]interface{}{"ok": color.GreenString("ok:")}))
- }
-
- if Flags.property.apiversion {
- delete(props, "APIVERSION")
- okMsg += fmt.Sprintf(
- wski18n.T("{{.ok}} whisk API version unset",
- map[string]interface{}{"ok": color.GreenString("ok:")}))
- if len(DefaultAPIVersion) > 0 {
- okMsg += fmt.Sprintf(
- wski18n.T("; the default value of {{.default}} will be used.\n",
- map[string]interface{}{"default": boldString(DefaultAPIVersion)}))
- } else {
- okMsg += fmt.Sprint(
- wski18n.T("; there is no default value that can be used.\n"))
- }
- }
-
- err = WriteProps(Properties.PropsFile, props)
- if err != nil {
- whisk.Debug(whisk.DbgError, "writeProps(%s, %#v) failed: %s\n", Properties.PropsFile, props, err)
- errStr := fmt.Sprintf(
- wski18n.T("Unable to unset the property value: {{.err}}",
- map[string]interface{}{"err": err}))
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output, okMsg)
- if err = loadProperties(); err != nil {
- whisk.Debug(whisk.DbgError, "loadProperties() failed: %s\n", err)
- }
- return nil
- },
+ Use: "unset",
+ Short: wski18n.T("unset property"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var okMsg string = ""
+ props, err := ReadProps(Properties.PropsFile)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
+ errStr := fmt.Sprintf(
+ wski18n.T("Unable to unset the property value: {{.err}}",
+ map[string]interface{}{"err": err}))
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ // read in each flag, update if necessary
+
+ if Flags.property.cert {
+ delete(props, "CERT")
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} client cert unset.\n",
+ map[string]interface{}{"ok": color.GreenString("ok:")}))
+ }
+
+ if Flags.property.key {
+ delete(props, "KEY")
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} client key unset.\n",
+ map[string]interface{}{"ok": color.GreenString("ok:")}))
+ }
+
+ if Flags.property.auth {
+ delete(props, "AUTH")
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} whisk auth unset.\n",
+ map[string]interface{}{"ok": color.GreenString("ok:")}))
+ }
+
+ if Flags.property.namespace {
+ delete(props, "NAMESPACE")
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} whisk namespace unset",
+ map[string]interface{}{"ok": color.GreenString("ok:")}))
+ if len(DefaultNamespace) > 0 {
+ okMsg += fmt.Sprintf(
+ wski18n.T("; the default value of {{.default}} will be used.\n",
+ map[string]interface{}{"default": boldString(DefaultNamespace)}))
+ } else {
+ okMsg += fmt.Sprint(
+ wski18n.T("; there is no default value that can be used.\n"))
+ }
+ }
+
+ if Flags.property.apihost {
+ delete(props, "APIHOST")
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} whisk API host unset.\n",
+ map[string]interface{}{"ok": color.GreenString("ok:")}))
+ }
+
+ if Flags.property.apiversion {
+ delete(props, "APIVERSION")
+ okMsg += fmt.Sprintf(
+ wski18n.T("{{.ok}} whisk API version unset",
+ map[string]interface{}{"ok": color.GreenString("ok:")}))
+ if len(DefaultAPIVersion) > 0 {
+ okMsg += fmt.Sprintf(
+ wski18n.T("; the default value of {{.default}} will be used.\n",
+ map[string]interface{}{"default": boldString(DefaultAPIVersion)}))
+ } else {
+ okMsg += fmt.Sprint(
+ wski18n.T("; there is no default value that can be used.\n"))
+ }
+ }
+
+ err = WriteProps(Properties.PropsFile, props)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "writeProps(%s, %#v) failed: %s\n", Properties.PropsFile, props, err)
+ errStr := fmt.Sprintf(
+ wski18n.T("Unable to unset the property value: {{.err}}",
+ map[string]interface{}{"err": err}))
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output, okMsg)
+ if err = loadProperties(); err != nil {
+ whisk.Debug(whisk.DbgError, "loadProperties() failed: %s\n", err)
+ }
+ return nil
+ },
}
var propertyGetCmd = &cobra.Command{
- Use: "get",
- Short: wski18n.T("get property"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
-
- // If no property is explicitly specified, default to all properties
- if !(Flags.property.all || Flags.property.cert ||
- Flags.property.key || Flags.property.auth ||
- Flags.property.apiversion || Flags.property.cliversion ||
- Flags.property.namespace || Flags.property.apibuild ||
- Flags.property.apihost || Flags.property.apibuildno) {
- Flags.property.all = true
- }
-
- if Flags.property.all || Flags.property.cert {
- fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("client cert"), boldString(Properties.Cert))
- }
-
- if Flags.property.all || Flags.property.key {
- fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("Client key"), boldString(Properties.Key))
- }
-
- if Flags.property.all || Flags.property.auth {
- fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk auth"), boldString(Properties.Auth))
- }
-
- if Flags.property.all || Flags.property.apihost {
- fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk API host"), boldString(Properties.APIHost))
- }
-
- if Flags.property.all || Flags.property.apiversion {
- fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk API version"), boldString(Properties.APIVersion))
- }
-
- if Flags.property.all || Flags.property.namespace {
- fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk namespace"), boldString(Properties.Namespace))
- }
-
- if Flags.property.all || Flags.property.cliversion {
- fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk CLI version"), boldString(Properties.CLIVersion))
- }
-
- if Flags.property.all || Flags.property.apibuild || Flags.property.apibuildno {
- info, _, err := Client.Info.Get()
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Info.Get() failed: %s\n", err)
- info = &whisk.Info{}
- info.Build = wski18n.T("Unknown")
- info.BuildNo = wski18n.T("Unknown")
- }
- if Flags.property.all || Flags.property.apibuild {
- fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk API build"), boldString(info.Build))
- }
- if Flags.property.all || Flags.property.apibuildno {
- fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk API build number"), boldString(info.BuildNo))
- }
- if err != nil {
- errStr := fmt.Sprintf(
- wski18n.T("Unable to obtain API build information: {{.err}}",
- map[string]interface{}{"err": err}))
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- }
-
- return nil
- },
+ Use: "get",
+ Short: wski18n.T("get property"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+
+ // If no property is explicitly specified, default to all properties
+ if !(Flags.property.all || Flags.property.cert ||
+ Flags.property.key || Flags.property.auth ||
+ Flags.property.apiversion || Flags.property.cliversion ||
+ Flags.property.namespace || Flags.property.apibuild ||
+ Flags.property.apihost || Flags.property.apibuildno) {
+ Flags.property.all = true
+ }
+
+ if Flags.property.all || Flags.property.cert {
+ fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("client cert"), boldString(Properties.Cert))
+ }
+
+ if Flags.property.all || Flags.property.key {
+ fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("Client key"), boldString(Properties.Key))
+ }
+
+ if Flags.property.all || Flags.property.auth {
+ fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk auth"), boldString(Properties.Auth))
+ }
+
+ if Flags.property.all || Flags.property.apihost {
+ fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk API host"), boldString(Properties.APIHost))
+ }
+
+ if Flags.property.all || Flags.property.apiversion {
+ fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk API version"), boldString(Properties.APIVersion))
+ }
+
+ if Flags.property.all || Flags.property.namespace {
+ fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk namespace"), boldString(Properties.Namespace))
+ }
+
+ if Flags.property.all || Flags.property.cliversion {
+ fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk CLI version"), boldString(Properties.CLIVersion))
+ }
+
+ if Flags.property.all || Flags.property.apibuild || Flags.property.apibuildno {
+ info, _, err := Client.Info.Get()
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Info.Get() failed: %s\n", err)
+ info = &whisk.Info{}
+ info.Build = wski18n.T("Unknown")
+ info.BuildNo = wski18n.T("Unknown")
+ }
+ if Flags.property.all || Flags.property.apibuild {
+ fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk API build"), boldString(info.Build))
+ }
+ if Flags.property.all || Flags.property.apibuildno {
+ fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk API build number"), boldString(info.BuildNo))
+ }
+ if err != nil {
+ errStr := fmt.Sprintf(
+ wski18n.T("Unable to obtain API build information: {{.err}}",
+ map[string]interface{}{"err": err}))
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ }
+
+ return nil
+ },
}
func init() {
- propertyCmd.AddCommand(
- propertySetCmd,
- propertyUnsetCmd,
- propertyGetCmd,
- )
-
- // need to set property flags as booleans instead of strings... perhaps with boolApihost...
- propertyGetCmd.Flags().BoolVar(&Flags.property.cert, "cert", false, wski18n.T("client cert"))
- propertyGetCmd.Flags().BoolVar(&Flags.property.key, "key", false, wski18n.T("client key"))
- propertyGetCmd.Flags().BoolVar(&Flags.property.auth, "auth", false, wski18n.T("authorization key"))
- propertyGetCmd.Flags().BoolVar(&Flags.property.apihost, "apihost", false, wski18n.T("whisk API host"))
- propertyGetCmd.Flags().BoolVar(&Flags.property.apiversion, "apiversion", false, wski18n.T("whisk API version"))
- propertyGetCmd.Flags().BoolVar(&Flags.property.apibuild, "apibuild", false, wski18n.T("whisk API build version"))
- propertyGetCmd.Flags().BoolVar(&Flags.property.apibuildno, "apibuildno", false, wski18n.T("whisk API build number"))
- propertyGetCmd.Flags().BoolVar(&Flags.property.cliversion, "cliversion", false, wski18n.T("whisk CLI version"))
- propertyGetCmd.Flags().BoolVar(&Flags.property.namespace, "namespace", false, wski18n.T("whisk namespace"))
- propertyGetCmd.Flags().BoolVar(&Flags.property.all, "all", false, wski18n.T("all properties"))
-
- propertySetCmd.Flags().StringVarP(&Flags.Global.Auth, "auth", "u", "", wski18n.T("authorization `KEY`"))
- propertySetCmd.Flags().StringVar(&Flags.Global.Cert, "cert", "", wski18n.T("client cert"))
- propertySetCmd.Flags().StringVar(&Flags.Global.Key, "key", "", wski18n.T("client key"))
- propertySetCmd.Flags().StringVar(&Flags.property.apihostSet, "apihost", "", wski18n.T("whisk API `HOST`"))
- propertySetCmd.Flags().StringVar(&Flags.property.apiversionSet, "apiversion", "", wski18n.T("whisk API `VERSION`"))
- propertySetCmd.Flags().StringVar(&Flags.property.namespaceSet, "namespace", "", wski18n.T("whisk `NAMESPACE`"))
-
- propertyUnsetCmd.Flags().BoolVar(&Flags.property.cert, "cert", false, wski18n.T("client cert"))
- propertyUnsetCmd.Flags().BoolVar(&Flags.property.key, "key", false, wski18n.T("client key"))
- propertyUnsetCmd.Flags().BoolVar(&Flags.property.auth, "auth", false, wski18n.T("authorization key"))
- propertyUnsetCmd.Flags().BoolVar(&Flags.property.apihost, "apihost", false, wski18n.T("whisk API host"))
- propertyUnsetCmd.Flags().BoolVar(&Flags.property.apiversion, "apiversion", false, wski18n.T("whisk API version"))
- propertyUnsetCmd.Flags().BoolVar(&Flags.property.namespace, "namespace", false, wski18n.T("whisk namespace"))
+ propertyCmd.AddCommand(
+ propertySetCmd,
+ propertyUnsetCmd,
+ propertyGetCmd,
+ )
+
+ // need to set property flags as booleans instead of strings... perhaps with boolApihost...
+ propertyGetCmd.Flags().BoolVar(&Flags.property.cert, "cert", false, wski18n.T("client cert"))
+ propertyGetCmd.Flags().BoolVar(&Flags.property.key, "key", false, wski18n.T("client key"))
+ propertyGetCmd.Flags().BoolVar(&Flags.property.auth, "auth", false, wski18n.T("authorization key"))
+ propertyGetCmd.Flags().BoolVar(&Flags.property.apihost, "apihost", false, wski18n.T("whisk API host"))
+ propertyGetCmd.Flags().BoolVar(&Flags.property.apiversion, "apiversion", false, wski18n.T("whisk API version"))
+ propertyGetCmd.Flags().BoolVar(&Flags.property.apibuild, "apibuild", false, wski18n.T("whisk API build version"))
+ propertyGetCmd.Flags().BoolVar(&Flags.property.apibuildno, "apibuildno", false, wski18n.T("whisk API build number"))
+ propertyGetCmd.Flags().BoolVar(&Flags.property.cliversion, "cliversion", false, wski18n.T("whisk CLI version"))
+ propertyGetCmd.Flags().BoolVar(&Flags.property.namespace, "namespace", false, wski18n.T("whisk namespace"))
+ propertyGetCmd.Flags().BoolVar(&Flags.property.all, "all", false, wski18n.T("all properties"))
+
+ propertySetCmd.Flags().StringVarP(&Flags.Global.Auth, "auth", "u", "", wski18n.T("authorization `KEY`"))
+ propertySetCmd.Flags().StringVar(&Flags.Global.Cert, "cert", "", wski18n.T("client cert"))
+ propertySetCmd.Flags().StringVar(&Flags.Global.Key, "key", "", wski18n.T("client key"))
+ propertySetCmd.Flags().StringVar(&Flags.property.apihostSet, "apihost", "", wski18n.T("whisk API `HOST`"))
+ propertySetCmd.Flags().StringVar(&Flags.property.apiversionSet, "apiversion", "", wski18n.T("whisk API `VERSION`"))
+ propertySetCmd.Flags().StringVar(&Flags.property.namespaceSet, "namespace", "", wski18n.T("whisk `NAMESPACE`"))
+
+ propertyUnsetCmd.Flags().BoolVar(&Flags.property.cert, "cert", false, wski18n.T("client cert"))
+ propertyUnsetCmd.Flags().BoolVar(&Flags.property.key, "key", false, wski18n.T("client key"))
+ propertyUnsetCmd.Flags().BoolVar(&Flags.property.auth, "auth", false, wski18n.T("authorization key"))
+ propertyUnsetCmd.Flags().BoolVar(&Flags.property.apihost, "apihost", false, wski18n.T("whisk API host"))
+ propertyUnsetCmd.Flags().BoolVar(&Flags.property.apiversion, "apiversion", false, wski18n.T("whisk API version"))
+ propertyUnsetCmd.Flags().BoolVar(&Flags.property.namespace, "namespace", false, wski18n.T("whisk namespace"))
}
func SetDefaultProperties() {
- Properties.Key = DefaultCert
- Properties.Cert = DefaultKey
- Properties.Auth = DefaultAuth
- Properties.Namespace = DefaultNamespace
- Properties.APIHost = DefaultAPIHost
- Properties.APIBuild = DefaultAPIBuild
- Properties.APIBuildNo = DefaultAPIBuildNo
- Properties.APIVersion = DefaultAPIVersion
- Properties.PropsFile = DefaultPropsFile
- // Properties.CLIVersion value is set from main's init()
+ Properties.Key = DefaultCert
+ Properties.Cert = DefaultKey
+ Properties.Auth = DefaultAuth
+ Properties.Namespace = DefaultNamespace
+ Properties.APIHost = DefaultAPIHost
+ Properties.APIBuild = DefaultAPIBuild
+ Properties.APIBuildNo = DefaultAPIBuildNo
+ Properties.APIVersion = DefaultAPIVersion
+ Properties.PropsFile = DefaultPropsFile
+ // Properties.CLIVersion value is set from main's init()
}
func GetPropertiesFilePath() (propsFilePath string, werr error) {
- var envExists bool
-
- // WSK_CONFIG_FILE environment variable overrides the default properties file path
- // NOTE: If this variable is set to an empty string or non-existent/unreadable file
- // - any existing $HOME/.wskprops is ignored
- // - a default configuration is used
- if propsFilePath, envExists = os.LookupEnv("WSK_CONFIG_FILE"); envExists {
- whisk.Debug(whisk.DbgInfo, "Using properties file '%s' from WSK_CONFIG_FILE environment variable\n", propsFilePath)
- return propsFilePath, nil
- } else {
- var err error
-
- propsFilePath, err = homedir.Expand(Properties.PropsFile)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "homedir.Expand(%s) failed: %s\n", Properties.PropsFile, err)
- errStr := fmt.Sprintf(
- wski18n.T("Unable to locate properties file '{{.filename}}': {{.err}}",
- map[string]interface{}{"filename": Properties.PropsFile, "err": err}))
- werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return propsFilePath, werr
- }
-
- whisk.Debug(whisk.DbgInfo, "Using properties file home dir '%s'\n", propsFilePath)
- }
-
- return propsFilePath, nil
+ var envExists bool
+
+ // WSK_CONFIG_FILE environment variable overrides the default properties file path
+ // NOTE: If this variable is set to an empty string or non-existent/unreadable file
+ // - any existing $HOME/.wskprops is ignored
+ // - a default configuration is used
+ if propsFilePath, envExists = os.LookupEnv("WSK_CONFIG_FILE"); envExists {
+ whisk.Debug(whisk.DbgInfo, "Using properties file '%s' from WSK_CONFIG_FILE environment variable\n", propsFilePath)
+ return propsFilePath, nil
+ } else {
+ var err error
+
+ propsFilePath, err = homedir.Expand(Properties.PropsFile)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "homedir.Expand(%s) failed: %s\n", Properties.PropsFile, err)
+ errStr := fmt.Sprintf(
+ wski18n.T("Unable to locate properties file '{{.filename}}': {{.err}}",
+ map[string]interface{}{"filename": Properties.PropsFile, "err": err}))
+ werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return propsFilePath, werr
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Using properties file home dir '%s'\n", propsFilePath)
+ }
+
+ return propsFilePath, nil
}
func loadProperties() error {
- var err error
-
- SetDefaultProperties()
-
- Properties.PropsFile, err = GetPropertiesFilePath()
- if err != nil {
- return nil
- //whisk.Debug(whisk.DbgError, "GetPropertiesFilePath() failed: %s\n", err)
- //errStr := fmt.Sprintf("Unable to load the properties file: %s", err)
- //werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- //return werr
- }
-
- props, err := ReadProps(Properties.PropsFile)
- if err != nil {
- whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
- errStr := wski18n.T("Unable to read the properties file '{{.filename}}': {{.err}}",
- map[string]interface{}{"filename": Properties.PropsFile, "err": err})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- if cert, hasProp := props["CERT"]; hasProp {
- Properties.Cert = cert
- }
-
- if key, hasProp := props["KEY"]; hasProp {
- Properties.Key = key
- }
-
- if authToken, hasProp := props["AUTH"]; hasProp {
- Properties.Auth = authToken
- }
-
- if authToken := os.Getenv("WHISK_AUTH"); len(authToken) > 0 {
- Properties.Auth = authToken
- }
-
- if apiVersion, hasProp := props["APIVERSION"]; hasProp {
- Properties.APIVersion = apiVersion
- }
-
- if apiVersion := os.Getenv("WHISK_APIVERSION"); len(apiVersion) > 0 {
- Properties.APIVersion = apiVersion
- }
-
- if apiHost, hasProp := props["APIHOST"]; hasProp {
- Properties.APIHost = apiHost
- }
-
- if apiHost := os.Getenv("WHISK_APIHOST"); len(apiHost) > 0 {
- Properties.APIHost = apiHost
- }
-
- if namespace, hasProp := props["NAMESPACE"]; hasProp && len(namespace) > 0 {
- Properties.Namespace = namespace
- }
-
- if namespace := os.Getenv("WHISK_NAMESPACE"); len(namespace) > 0 {
- Properties.Namespace = namespace
- }
-
- return nil
+ var err error
+
+ SetDefaultProperties()
+
+ Properties.PropsFile, err = GetPropertiesFilePath()
+ if err != nil {
+ return nil
+ //whisk.Debug(whisk.DbgError, "GetPropertiesFilePath() failed: %s\n", err)
+ //errStr := fmt.Sprintf("Unable to load the properties file: %s", err)
+ //werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ //return werr
+ }
+
+ props, err := ReadProps(Properties.PropsFile)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
+ errStr := wski18n.T("Unable to read the properties file '{{.filename}}': {{.err}}",
+ map[string]interface{}{"filename": Properties.PropsFile, "err": err})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ if cert, hasProp := props["CERT"]; hasProp {
+ Properties.Cert = cert
+ }
+
+ if key, hasProp := props["KEY"]; hasProp {
+ Properties.Key = key
+ }
+
+ if authToken, hasProp := props["AUTH"]; hasProp {
+ Properties.Auth = authToken
+ }
+
+ if authToken := os.Getenv("WHISK_AUTH"); len(authToken) > 0 {
+ Properties.Auth = authToken
+ }
+
+ if apiVersion, hasProp := props["APIVERSION"]; hasProp {
+ Properties.APIVersion = apiVersion
+ }
+
+ if apiVersion := os.Getenv("WHISK_APIVERSION"); len(apiVersion) > 0 {
+ Properties.APIVersion = apiVersion
+ }
+
+ if apiHost, hasProp := props["APIHOST"]; hasProp {
+ Properties.APIHost = apiHost
+ }
+
+ if apiHost := os.Getenv("WHISK_APIHOST"); len(apiHost) > 0 {
+ Properties.APIHost = apiHost
+ }
+
+ if namespace, hasProp := props["NAMESPACE"]; hasProp && len(namespace) > 0 {
+ Properties.Namespace = namespace
+ }
+
+ if namespace := os.Getenv("WHISK_NAMESPACE"); len(namespace) > 0 {
+ Properties.Namespace = namespace
+ }
+
+ return nil
}
func parseConfigFlags(cmd *cobra.Command, args []string) error {
- if cert := Flags.Global.Cert; len(cert) > 0 {
- Properties.Cert = cert
- if Client != nil {
- Client.Config.Cert = cert
- }
- }
-
- if key := Flags.Global.Key; len(key) > 0 {
- Properties.Key = key
- if Client != nil {
- Client.Config.Key = key
- }
- }
-
- if auth := Flags.Global.Auth; len(auth) > 0 {
- Properties.Auth = auth
- if Client != nil {
- Client.Config.AuthToken = auth
- }
- }
-
- if namespace := Flags.property.namespaceSet; len(namespace) > 0 {
- Properties.Namespace = namespace
- if Client != nil {
- Client.Config.Namespace = namespace
- }
- }
-
- if apiVersion := Flags.Global.Apiversion; len(apiVersion) > 0 {
- Properties.APIVersion = apiVersion
- if Client != nil {
- Client.Config.Version = apiVersion
- }
- }
-
- if apiHost := Flags.Global.Apihost; len(apiHost) > 0 {
- Properties.APIHost = apiHost
- if Client != nil {
- Client.Config.Host = apiHost
- baseURL, err := whisk.GetURLBase(apiHost, DefaultOpenWhiskApiPath)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) failed: %s\n", apiHost, DefaultOpenWhiskApiPath, err)
- errStr := wski18n.T("Invalid host address '{{.host}}': {{.err}}",
- map[string]interface{}{"host": Properties.APIHost, "err": err})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- Client.Config.BaseURL = baseURL
- }
- }
-
- if Flags.Global.Debug {
- whisk.SetDebug(true)
- }
- if Flags.Global.Verbose {
- whisk.SetVerbose(true)
- }
-
- return nil
+ if cert := Flags.Global.Cert; len(cert) > 0 {
+ Properties.Cert = cert
+ if Client != nil {
+ Client.Config.Cert = cert
+ }
+ }
+
+ if key := Flags.Global.Key; len(key) > 0 {
+ Properties.Key = key
+ if Client != nil {
+ Client.Config.Key = key
+ }
+ }
+
+ if auth := Flags.Global.Auth; len(auth) > 0 {
+ Properties.Auth = auth
+ if Client != nil {
+ Client.Config.AuthToken = auth
+ }
+ }
+
+ if namespace := Flags.property.namespaceSet; len(namespace) > 0 {
+ Properties.Namespace = namespace
+ if Client != nil {
+ Client.Config.Namespace = namespace
+ }
+ }
+
+ if apiVersion := Flags.Global.Apiversion; len(apiVersion) > 0 {
+ Properties.APIVersion = apiVersion
+ if Client != nil {
+ Client.Config.Version = apiVersion
+ }
+ }
+
+ if apiHost := Flags.Global.Apihost; len(apiHost) > 0 {
+ Properties.APIHost = apiHost
+ if Client != nil {
+ Client.Config.Host = apiHost
+ baseURL, err := whisk.GetURLBase(apiHost, DefaultOpenWhiskApiPath)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) failed: %s\n", apiHost, DefaultOpenWhiskApiPath, err)
+ errStr := wski18n.T("Invalid host address '{{.host}}': {{.err}}",
+ map[string]interface{}{"host": Properties.APIHost, "err": err})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ Client.Config.BaseURL = baseURL
+ }
+ }
+
+ if Flags.Global.Debug {
+ whisk.SetDebug(true)
+ }
+ if Flags.Global.Verbose {
+ whisk.SetVerbose(true)
+ }
+
+ return nil
}
diff --git a/commands/qualified_name.go b/commands/qualified_name.go
index e3391cf..8209ee8 100644
--- a/commands/qualified_name.go
+++ b/commands/qualified_name.go
@@ -17,18 +17,18 @@
package commands
import (
- "errors"
- "fmt"
- "strings"
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
+ "strings"
)
type QualifiedName struct {
- namespace string // namespace. does not include leading '/'. may be "" (i.e. default namespace)
- packageName string // package. may be "". does not include leading/trailing '/'
- entity string // entity. should not be ""
- EntityName string // pkg+entity
+ namespace string // namespace. does not include leading '/'. may be "" (i.e. default namespace)
+ packageName string // package. may be "". does not include leading/trailing '/'
+ entity string // entity. should not be ""
+ EntityName string // pkg+entity
}
///////////////////////////
@@ -39,40 +39,40 @@ type QualifiedName struct {
// from qualifiedName with proper syntax.
// Example: /namespace/[package/]entity
func (qualifiedName *QualifiedName) GetFullQualifiedName() string {
- output := []string{}
+ output := []string{}
- if len(qualifiedName.GetNamespace()) > 0 {
- output = append(output, "/", qualifiedName.GetNamespace(), "/")
- }
- if len(qualifiedName.GetPackageName()) > 0 {
- output = append(output, qualifiedName.GetPackageName(), "/")
- }
- output = append(output, qualifiedName.GetEntity())
+ if len(qualifiedName.GetNamespace()) > 0 {
+ output = append(output, "/", qualifiedName.GetNamespace(), "/")
+ }
+ if len(qualifiedName.GetPackageName()) > 0 {
+ output = append(output, qualifiedName.GetPackageName(), "/")
+ }
+ output = append(output, qualifiedName.GetEntity())
- return strings.Join(output, "")
+ return strings.Join(output, "")
}
// GetPackageName() returns the package name from qualifiedName without a
// leading '/'
func (qualifiedName *QualifiedName) GetPackageName() string {
- return qualifiedName.packageName
+ return qualifiedName.packageName
}
// GetEntityName() returns the entity name ([package/]entity) of qualifiedName
// without a leading '/'
func (qualifiedName *QualifiedName) GetEntityName() string {
- return qualifiedName.EntityName
+ return qualifiedName.EntityName
}
// GetEntity() returns the name of entity in qualifiedName without a leading '/'
func (qualifiedName *QualifiedName) GetEntity() string {
- return qualifiedName.entity
+ return qualifiedName.entity
}
// GetNamespace() returns the name of the namespace in qualifiedName without
// a leading '/'
func (qualifiedName *QualifiedName) GetNamespace() string {
- return qualifiedName.namespace
+ return qualifiedName.namespace
}
// NewQualifiedName(name) initializes and constructs a (possibly fully qualified)
@@ -89,51 +89,51 @@ func (qualifiedName *QualifiedName) GetNamespace() string {
// /ns/foo => qualifiedName {namespace: ns, entityName: foo}
// /ns/pkg/foo => qualifiedName {namespace: ns, entityName: pkg/foo}
func NewQualifiedName(name string) (*QualifiedName, error) {
- qualifiedName := new(QualifiedName)
-
- // If name has a preceding delimiter (/), or if it has two delimiters with a
- // leading non-empty string, then it contains a namespace. Otherwise the name
- // does not specify a namespace, so default the namespace to the namespace
- // value set in the properties file; if that is not set, use "_"
- name = addLeadSlash(name)
- parts := strings.Split(name, "/")
- if strings.HasPrefix(name, "/") {
- qualifiedName.namespace = parts[1]
-
- if len(parts) < 2 || len(parts) > 4 {
- return qualifiedName, qualifiedNameNotSpecifiedErr()
- }
-
- for i := 1; i < len(parts); i++ {
- if len(parts[i]) == 0 || parts[i] == "." {
- return qualifiedName, qualifiedNameNotSpecifiedErr()
- }
- }
-
- qualifiedName.EntityName = strings.Join(parts[2:], "/")
- if len(parts) == 4 {
- qualifiedName.packageName = parts[2]
- }
- qualifiedName.entity = parts[len(parts)-1]
- } else {
- if len(name) == 0 || name == "." {
- return qualifiedName, qualifiedNameNotSpecifiedErr()
- }
-
- qualifiedName.entity = parts[len(parts)-1]
- if len(parts) == 2 {
- qualifiedName.packageName = parts[0]
- }
- qualifiedName.EntityName = name
- qualifiedName.namespace = getNamespaceFromProp()
- }
-
- whisk.Debug(whisk.DbgInfo, "Qualified pkg+entity (EntityName): %s\n", qualifiedName.GetEntityName())
- whisk.Debug(whisk.DbgInfo, "Qualified namespace: %s\n", qualifiedName.GetNamespace())
- whisk.Debug(whisk.DbgInfo, "Qualified package: %s\n", qualifiedName.GetPackageName())
- whisk.Debug(whisk.DbgInfo, "Qualified entity: %s\n", qualifiedName.GetEntity())
-
- return qualifiedName, nil
+ qualifiedName := new(QualifiedName)
+
+ // If name has a preceding delimiter (/), or if it has two delimiters with a
+ // leading non-empty string, then it contains a namespace. Otherwise the name
+ // does not specify a namespace, so default the namespace to the namespace
+ // value set in the properties file; if that is not set, use "_"
+ name = addLeadSlash(name)
+ parts := strings.Split(name, "/")
+ if strings.HasPrefix(name, "/") {
+ qualifiedName.namespace = parts[1]
+
+ if len(parts) < 2 || len(parts) > 4 {
+ return qualifiedName, qualifiedNameNotSpecifiedErr()
+ }
+
+ for i := 1; i < len(parts); i++ {
+ if len(parts[i]) == 0 || parts[i] == "." {
+ return qualifiedName, qualifiedNameNotSpecifiedErr()
+ }
+ }
+
+ qualifiedName.EntityName = strings.Join(parts[2:], "/")
+ if len(parts) == 4 {
+ qualifiedName.packageName = parts[2]
+ }
+ qualifiedName.entity = parts[len(parts)-1]
+ } else {
+ if len(name) == 0 || name == "." {
+ return qualifiedName, qualifiedNameNotSpecifiedErr()
+ }
+
+ qualifiedName.entity = parts[len(parts)-1]
+ if len(parts) == 2 {
+ qualifiedName.packageName = parts[0]
+ }
+ qualifiedName.EntityName = name
+ qualifiedName.namespace = getNamespaceFromProp()
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Qualified pkg+entity (EntityName): %s\n", qualifiedName.GetEntityName())
+ whisk.Debug(whisk.DbgInfo, "Qualified namespace: %s\n", qualifiedName.GetNamespace())
+ whisk.Debug(whisk.DbgInfo, "Qualified package: %s\n", qualifiedName.GetPackageName())
+ whisk.Debug(whisk.DbgInfo, "Qualified entity: %s\n", qualifiedName.GetEntity())
+
+ return qualifiedName, nil
}
/////////////////////
@@ -144,24 +144,24 @@ func NewQualifiedName(name string) (*QualifiedName, error) {
// invalid qualified names detected while building a new
// QualifiedName struct.
func qualifiedNameNotSpecifiedErr() error {
- whisk.Debug(whisk.DbgError, "A valid qualified name was not detected\n")
- errStr := wski18n.T("A valid qualified name must be specified.")
- return whisk.MakeWskError(errors.New(errStr), whisk.NOT_ALLOWED, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ whisk.Debug(whisk.DbgError, "A valid qualified name was not detected\n")
+ errStr := wski18n.T("A valid qualified name must be specified.")
+ return whisk.MakeWskError(errors.New(errStr), whisk.NOT_ALLOWED, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
}
// NewQualifiedNameError(entityName, err) returns specific whisk error
// for invalid qualified names.
-func NewQualifiedNameError(entityName string, err error) (error) {
- whisk.Debug(whisk.DbgError, "NewQualifiedName(%s) failed: %s\n", entityName, err)
+func NewQualifiedNameError(entityName string, err error) error {
+ whisk.Debug(whisk.DbgError, "NewQualifiedName(%s) failed: %s\n", entityName, err)
- errMsg := wski18n.T(
- "'{{.name}}' is not a valid qualified name: {{.err}}",
- map[string]interface{}{
- "name": entityName,
- "err": err,
- })
+ errMsg := wski18n.T(
+ "'{{.name}}' is not a valid qualified name: {{.err}}",
+ map[string]interface{}{
+ "name": entityName,
+ "err": err,
+ })
- return whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
}
///////////////////////////
@@ -172,23 +172,23 @@ func NewQualifiedNameError(entityName string, err error) (error) {
// inserting a leading '/' if it is of 3 parts (namespace/package/action)
// and lacking the leading '/'.
func addLeadSlash(name string) string {
- parts := strings.Split(name, "/")
- if len(parts) == 3 && parts[0] != "" {
- name = "/" + name
- }
- return name
+ parts := strings.Split(name, "/")
+ if len(parts) == 3 && parts[0] != "" {
+ name = "/" + name
+ }
+ return name
}
// getNamespaceFromProp() returns a namespace from Properties if one exists,
// else defaults to returning "_"
-func getNamespaceFromProp() (string) {
- namespace := "_"
+func getNamespaceFromProp() string {
+ namespace := "_"
- if Properties.Namespace != "" {
- namespace = Properties.Namespace
- }
+ if Properties.Namespace != "" {
+ namespace = Properties.Namespace
+ }
- return namespace
+ return namespace
}
// getQualifiedName(name, namespace) returns a fully qualified name given a
@@ -200,16 +200,16 @@ func getNamespaceFromProp() (string) {
// (foo, ns) => /ns/foo
// (/ns/pkg/foo, None) => /ns/pkg/foo
// (/ns/pkg/foo, otherns) => /ns/pkg/foo
-func getQualifiedName(name string, namespace string) (string) {
- name = addLeadSlash(name)
- if strings.HasPrefix(name, "/") {
- return name
- } else if strings.HasPrefix(namespace, "/") {
- return fmt.Sprintf("%s/%s", namespace, name)
- } else {
- if len(namespace) == 0 {
- namespace = Properties.Namespace
- }
- return fmt.Sprintf("/%s/%s", namespace, name)
- }
+func getQualifiedName(name string, namespace string) string {
+ name = addLeadSlash(name)
+ if strings.HasPrefix(name, "/") {
+ return name
+ } else if strings.HasPrefix(namespace, "/") {
+ return fmt.Sprintf("%s/%s", namespace, name)
+ } else {
+ if len(namespace) == 0 {
+ namespace = Properties.Namespace
+ }
+ return fmt.Sprintf("/%s/%s", namespace, name)
+ }
}
diff --git a/commands/rule.go b/commands/rule.go
index dddbc3b..6092d8c 100644
--- a/commands/rule.go
+++ b/commands/rule.go
@@ -18,415 +18,415 @@
package commands
import (
- "errors"
- "fmt"
+ "errors"
+ "fmt"
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/fatih/color"
- "github.com/spf13/cobra"
+ "github.com/fatih/color"
+ "github.com/spf13/cobra"
)
// ruleCmd represents the rule command
var ruleCmd = &cobra.Command{
- Use: "rule",
- Short: wski18n.T("work with rules"),
+ Use: "rule",
+ Short: wski18n.T("work with rules"),
}
var ruleEnableCmd = &cobra.Command{
- Use: "enable RULE_NAME",
- Short: wski18n.T("enable rule"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Rule enable", wski18n.T("A rule name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- ruleName := qualifiedName.GetEntityName()
-
- _, _, err = Client.Rules.SetState(ruleName, "active")
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Rules.SetState(%s, active) failed: %s\n", ruleName, err)
- errStr := wski18n.T("Unable to enable rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": ruleName, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} enabled rule {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
- return nil
- },
+ Use: "enable RULE_NAME",
+ Short: wski18n.T("enable rule"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Rule enable", wski18n.T("A rule name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ ruleName := qualifiedName.GetEntityName()
+
+ _, _, err = Client.Rules.SetState(ruleName, "active")
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Rules.SetState(%s, active) failed: %s\n", ruleName, err)
+ errStr := wski18n.T("Unable to enable rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": ruleName, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} enabled rule {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
+ return nil
+ },
}
var ruleDisableCmd = &cobra.Command{
- Use: "disable RULE_NAME",
- Short: wski18n.T("disable rule"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Rule disable", wski18n.T("A rule name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- ruleName := qualifiedName.GetEntityName()
-
- _, _, err = Client.Rules.SetState(ruleName, "inactive")
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Rules.SetState(%s, inactive) failed: %s\n", ruleName, err)
- errStr := wski18n.T("Unable to disable rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": ruleName, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} disabled rule {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
- return nil
- },
+ Use: "disable RULE_NAME",
+ Short: wski18n.T("disable rule"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Rule disable", wski18n.T("A rule name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ ruleName := qualifiedName.GetEntityName()
+
+ _, _, err = Client.Rules.SetState(ruleName, "inactive")
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Rules.SetState(%s, inactive) failed: %s\n", ruleName, err)
+ errStr := wski18n.T("Unable to disable rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": ruleName, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} disabled rule {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
+ return nil
+ },
}
var ruleStatusCmd = &cobra.Command{
- Use: "status RULE_NAME",
- Short: wski18n.T("get rule status"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Rule status", wski18n.T("A rule name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- ruleName := qualifiedName.GetEntityName()
-
- rule, _, err := Client.Rules.Get(ruleName)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Rules.Get(%s) failed: %s\n", ruleName, err)
- errStr := wski18n.T("Unable to get status of rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": ruleName, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} rule {{.name}} is {{.status}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName), "status": boldString(rule.Status)}))
- return nil
- },
+ Use: "status RULE_NAME",
+ Short: wski18n.T("get rule status"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Rule status", wski18n.T("A rule name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ ruleName := qualifiedName.GetEntityName()
+
+ rule, _, err := Client.Rules.Get(ruleName)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Rules.Get(%s) failed: %s\n", ruleName, err)
+ errStr := wski18n.T("Unable to get status of rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": ruleName, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} rule {{.name}} is {{.status}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName), "status": boldString(rule.Status)}))
+ return nil
+ },
}
var ruleCreateCmd = &cobra.Command{
- Use: "create RULE_NAME TRIGGER_NAME ACTION_NAME",
- Short: wski18n.T("create new rule"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 3, 3, "Rule create",
- wski18n.T("A rule, trigger and action name are required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- ruleName := qualifiedName.GetEntityName()
- triggerName := getQualifiedName(args[1], Properties.Namespace)
- actionName := getQualifiedName(args[2], Properties.Namespace)
-
- rule := &whisk.Rule{
- Name: ruleName,
- Trigger: triggerName,
- Action: actionName,
- }
-
- whisk.Debug(whisk.DbgInfo, "Inserting rule:\n%+v\n", rule)
- var retRule *whisk.Rule
- retRule, _, err = Client.Rules.Insert(rule, false)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Rules.Insert(%#v) failed: %s\n", rule, err)
- errStr := wski18n.T("Unable to create rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": ruleName, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- whisk.Debug(whisk.DbgInfo, "Inserted rule:\n%+v\n", retRule)
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} created rule {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
- return nil
- },
+ Use: "create RULE_NAME TRIGGER_NAME ACTION_NAME",
+ Short: wski18n.T("create new rule"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 3, 3, "Rule create",
+ wski18n.T("A rule, trigger and action name are required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ ruleName := qualifiedName.GetEntityName()
+ triggerName := getQualifiedName(args[1], Properties.Namespace)
+ actionName := getQualifiedName(args[2], Properties.Namespace)
+
+ rule := &whisk.Rule{
+ Name: ruleName,
+ Trigger: triggerName,
+ Action: actionName,
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Inserting rule:\n%+v\n", rule)
+ var retRule *whisk.Rule
+ retRule, _, err = Client.Rules.Insert(rule, false)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Rules.Insert(%#v) failed: %s\n", rule, err)
+ errStr := wski18n.T("Unable to create rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": ruleName, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ whisk.Debug(whisk.DbgInfo, "Inserted rule:\n%+v\n", retRule)
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} created rule {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
+ return nil
+ },
}
var ruleUpdateCmd = &cobra.Command{
- Use: "update RULE_NAME TRIGGER_NAME ACTION_NAME",
- Short: wski18n.T("update an existing rule, or create a rule if it does not exist"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 3, 3, "Rule update",
- wski18n.T("A rule, trigger and action name are required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- ruleName := qualifiedName.GetEntityName()
- triggerName := getQualifiedName(args[1], Properties.Namespace)
- actionName := getQualifiedName(args[2], Properties.Namespace)
-
- rule := &whisk.Rule{
- Name: ruleName,
- Trigger: triggerName,
- Action: actionName,
- }
-
- _, _, err = Client.Rules.Insert(rule, true)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Rules.Insert(%#v) failed: %s\n", rule, err)
- errStr := wski18n.T("Unable to update rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": rule.Name, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} updated rule {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
- return nil
- },
+ Use: "update RULE_NAME TRIGGER_NAME ACTION_NAME",
+ Short: wski18n.T("update an existing rule, or create a rule if it does not exist"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 3, 3, "Rule update",
+ wski18n.T("A rule, trigger and action name are required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ ruleName := qualifiedName.GetEntityName()
+ triggerName := getQualifiedName(args[1], Properties.Namespace)
+ actionName := getQualifiedName(args[2], Properties.Namespace)
+
+ rule := &whisk.Rule{
+ Name: ruleName,
+ Trigger: triggerName,
+ Action: actionName,
+ }
+
+ _, _, err = Client.Rules.Insert(rule, true)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Rules.Insert(%#v) failed: %s\n", rule, err)
+ errStr := wski18n.T("Unable to update rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": rule.Name, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} updated rule {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
+ return nil
+ },
}
var ruleGetCmd = &cobra.Command{
- Use: "get RULE_NAME",
- Short: wski18n.T("get rule"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var field string
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 2, "Rule get", wski18n.T("A rule name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if len(args) > 1 {
- field = args[1]
-
- if !fieldExists(&whisk.Rule{}, field){
- errMsg := wski18n.T("Invalid field filter '{{.arg}}'.", map[string]interface{}{"arg": field})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- ruleName := qualifiedName.GetEntityName()
-
- rule, _, err := Client.Rules.Get(ruleName)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Rules.Get(%s) failed: %s\n", ruleName, err)
- errStr := wski18n.T("Unable to get rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": ruleName, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- if (Flags.rule.summary) {
- printRuleSummary(rule)
- } else {
- if len(field) > 0 {
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got rule {{.name}}, displaying field {{.field}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName),
- "field": field}))
- printField(rule, field)
- } else {
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got rule {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
- printJSON(rule)
- }
- }
-
- return nil
- },
+ Use: "get RULE_NAME",
+ Short: wski18n.T("get rule"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var field string
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 2, "Rule get", wski18n.T("A rule name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if len(args) > 1 {
+ field = args[1]
+
+ if !fieldExists(&whisk.Rule{}, field) {
+ errMsg := wski18n.T("Invalid field filter '{{.arg}}'.", map[string]interface{}{"arg": field})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ ruleName := qualifiedName.GetEntityName()
+
+ rule, _, err := Client.Rules.Get(ruleName)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Rules.Get(%s) failed: %s\n", ruleName, err)
+ errStr := wski18n.T("Unable to get rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": ruleName, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ if Flags.rule.summary {
+ printRuleSummary(rule)
+ } else {
+ if len(field) > 0 {
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got rule {{.name}}, displaying field {{.field}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName),
+ "field": field}))
+ printField(rule, field)
+ } else {
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got rule {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
+ printJSON(rule)
+ }
+ }
+
+ return nil
+ },
}
var ruleDeleteCmd = &cobra.Command{
- Use: "delete RULE_NAME",
- Short: wski18n.T("delete rule"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Rule delete", wski18n.T("A rule name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- ruleName := qualifiedName.GetEntityName()
-
- if Flags.rule.disable {
- _, _, err := Client.Rules.SetState(ruleName, "inactive")
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Rules.SetState(%s, inactive) failed: %s\n", ruleName, err)
- errStr := wski18n.T("Unable to disable rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": ruleName, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- }
-
- _, err = Client.Rules.Delete(ruleName)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Rules.Delete(%s) error: %s\n", ruleName, err)
- errStr := wski18n.T("Unable to delete rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": ruleName, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} deleted rule {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
- return nil
- },
+ Use: "delete RULE_NAME",
+ Short: wski18n.T("delete rule"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Rule delete", wski18n.T("A rule name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ ruleName := qualifiedName.GetEntityName()
+
+ if Flags.rule.disable {
+ _, _, err := Client.Rules.SetState(ruleName, "inactive")
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Rules.SetState(%s, inactive) failed: %s\n", ruleName, err)
+ errStr := wski18n.T("Unable to disable rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": ruleName, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ }
+
+ _, err = Client.Rules.Delete(ruleName)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Rules.Delete(%s) error: %s\n", ruleName, err)
+ errStr := wski18n.T("Unable to delete rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": ruleName, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} deleted rule {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(ruleName)}))
+ return nil
+ },
}
var ruleListCmd = &cobra.Command{
- Use: "list [NAMESPACE]",
- Short: wski18n.T("list all rules"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 0, 1, "Rule list",
- wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
- return whiskErr
- }
-
- if len(args) == 1 {
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- if len(qualifiedName.GetEntityName()) > 0 {
- return entityNameError(qualifiedName.GetEntityName())
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- }
-
- ruleListOptions := &whisk.RuleListOptions{
- Skip: Flags.common.skip,
- Limit: Flags.common.limit,
- }
-
- rules, _, err := Client.Rules.List(ruleListOptions)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Rules.List(%#v) error: %s\n", ruleListOptions, err)
- errStr := wski18n.T("Unable to obtain the list of rules for namespace '{{.name}}': {{.err}}",
- map[string]interface{}{"name": getClientNamespace(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- } else {
- //No errors, lets attempt to retrieve the status of each rule #312
- for index, rule := range rules {
- ruleStatus, _, err := Client.Rules.Get(rule.Name)
- if err != nil {
- errStr := wski18n.T("Unable to get status of rule '{{.name}}': {{.err}}",
- map[string]interface{}{"name": rule.Name, "err": err})
- fmt.Println(errStr)
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- rules[index].Status = ruleStatus.Status
- }
- }
-
- sortByName := Flags.common.nameSort
- printList(rules, sortByName)
- return nil
- },
+ Use: "list [NAMESPACE]",
+ Short: wski18n.T("list all rules"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 0, 1, "Rule list",
+ wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if len(args) == 1 {
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ if len(qualifiedName.GetEntityName()) > 0 {
+ return entityNameError(qualifiedName.GetEntityName())
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+ }
+
+ ruleListOptions := &whisk.RuleListOptions{
+ Skip: Flags.common.skip,
+ Limit: Flags.common.limit,
+ }
+
+ rules, _, err := Client.Rules.List(ruleListOptions)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Rules.List(%#v) error: %s\n", ruleListOptions, err)
+ errStr := wski18n.T("Unable to obtain the list of rules for namespace '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": getClientNamespace(), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ } else {
+ //No errors, lets attempt to retrieve the status of each rule #312
+ for index, rule := range rules {
+ ruleStatus, _, err := Client.Rules.Get(rule.Name)
+ if err != nil {
+ errStr := wski18n.T("Unable to get status of rule '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": rule.Name, "err": err})
+ fmt.Println(errStr)
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ rules[index].Status = ruleStatus.Status
+ }
+ }
+
+ sortByName := Flags.common.nameSort
+ printList(rules, sortByName)
+ return nil
+ },
}
func init() {
- ruleDeleteCmd.Flags().BoolVar(&Flags.rule.disable, "disable", false, wski18n.T("automatically disable rule before deleting it"))
-
- ruleGetCmd.Flags().BoolVarP(&Flags.rule.summary, "summary", "s", false, wski18n.T("summarize rule details"))
-
- ruleListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of rules from the result"))
- ruleListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", 30, wski18n.T("only return `LIMIT` number of rules from the collection"))
- ruleListCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by entity name; only applicable within the limit/skip returned entity block"))
-
- ruleCmd.AddCommand(
- ruleCreateCmd,
- ruleEnableCmd,
- ruleDisableCmd,
- ruleStatusCmd,
- ruleUpdateCmd,
- ruleGetCmd,
- ruleDeleteCmd,
- ruleListCmd,
- )
+ ruleDeleteCmd.Flags().BoolVar(&Flags.rule.disable, "disable", false, wski18n.T("automatically disable rule before deleting it"))
+
+ ruleGetCmd.Flags().BoolVarP(&Flags.rule.summary, "summary", "s", false, wski18n.T("summarize rule details"))
+
+ ruleListCmd.Flags().IntVarP(&Flags.common.skip, "skip", "s", 0, wski18n.T("exclude the first `SKIP` number of rules from the result"))
+ ruleListCmd.Flags().IntVarP(&Flags.common.limit, "limit", "l", 30, wski18n.T("only return `LIMIT` number of rules from the collection"))
+ ruleListCmd.Flags().BoolVarP(&Flags.common.nameSort, "name-sort", "n", false, wski18n.T("sorts a list alphabetically by entity name; only applicable within the limit/skip returned entity block"))
+
+ ruleCmd.AddCommand(
+ ruleCreateCmd,
+ ruleEnableCmd,
+ ruleDisableCmd,
+ ruleStatusCmd,
+ ruleUpdateCmd,
+ ruleGetCmd,
+ ruleDeleteCmd,
+ ruleListCmd,
+ )
}
diff --git a/commands/sdk.go b/commands/sdk.go
index 4f4eaaf..1974a12 100644
--- a/commands/sdk.go
+++ b/commands/sdk.go
@@ -18,241 +18,242 @@
package commands
import (
- "errors"
- "fmt"
- "io"
- "os"
- "strings"
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "strings"
- "github.com/spf13/cobra"
+ "github.com/spf13/cobra"
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
)
// sdkCmd represents the sdk command
var sdkCmd = &cobra.Command{
- Use: "sdk",
- Short: wski18n.T("work with the sdk"),
+ Use: "sdk",
+ Short: wski18n.T("work with the sdk"),
}
type sdkInfo struct {
- UrlPath string
- FileName string
- isGzTar bool
- IsGzip bool
- IsZip bool
- IsTar bool
- Unpack bool
- UnpackDir string
+ UrlPath string
+ FileName string
+ isGzTar bool
+ IsGzip bool
+ IsZip bool
+ IsTar bool
+ Unpack bool
+ UnpackDir string
}
var sdkMap map[string]*sdkInfo
+
const SDK_DOCKER_COMPONENT_NAME string = "docker"
const SDK_IOS_COMPONENT_NAME string = "ios"
const BASH_AUTOCOMPLETE_FILENAME string = "wsk_cli_bash_completion.sh"
var sdkInstallCmd = &cobra.Command{
- Use: "install COMPONENT",
- Short: wski18n.T("install SDK artifacts"),
- Long: wski18n.T("install SDK artifacts, where valid COMPONENT values are docker, ios, and bashauto"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- if len(args) != 1 {
- whisk.Debug(whisk.DbgError, "Invalid number of arguments: %d\n", len(args))
- errStr := wski18n.T("The SDK component argument is missing. One component (docker, ios, or bashauto) must be specified")
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
- component := strings.ToLower(args[0])
- switch component {
- case "docker":
- err = dockerInstall()
- case "ios":
- err = iOSInstall()
- case "bashauto":
- if Flags.sdk.stdout {
- if err = WskCmd.GenBashCompletion(os.Stdout); err != nil {
- whisk.Debug(whisk.DbgError, "GenBashCompletion error: %s\n", err)
- errStr := wski18n.T("Unable to output bash command completion {{.err}}",
- map[string]interface{}{"err": err})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- } else {
- err = WskCmd.GenBashCompletionFile(BASH_AUTOCOMPLETE_FILENAME)
- if (err != nil) {
- whisk.Debug(whisk.DbgError, "GenBashCompletionFile('%s`) error: \n", BASH_AUTOCOMPLETE_FILENAME, err)
- errStr := wski18n.T("Unable to generate '{{.name}}': {{.err}}",
- map[string]interface{}{"name": BASH_AUTOCOMPLETE_FILENAME, "err": err})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- fmt.Printf(
- wski18n.T("bash_completion_msg",
- map[string]interface{}{"name": BASH_AUTOCOMPLETE_FILENAME}))
- }
- default:
- whisk.Debug(whisk.DbgError, "Invalid component argument '%s'\n", component)
- errStr := wski18n.T("The SDK component argument '{{.component}}' is invalid. Valid components are docker, ios and bashauto",
- map[string]interface{}{"component": component})
- err = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- }
+ Use: "install COMPONENT",
+ Short: wski18n.T("install SDK artifacts"),
+ Long: wski18n.T("install SDK artifacts, where valid COMPONENT values are docker, ios, and bashauto"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ if len(args) != 1 {
+ whisk.Debug(whisk.DbgError, "Invalid number of arguments: %d\n", len(args))
+ errStr := wski18n.T("The SDK component argument is missing. One component (docker, ios, or bashauto) must be specified")
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+ component := strings.ToLower(args[0])
+ switch component {
+ case "docker":
+ err = dockerInstall()
+ case "ios":
+ err = iOSInstall()
+ case "bashauto":
+ if Flags.sdk.stdout {
+ if err = WskCmd.GenBashCompletion(os.Stdout); err != nil {
+ whisk.Debug(whisk.DbgError, "GenBashCompletion error: %s\n", err)
+ errStr := wski18n.T("Unable to output bash command completion {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ } else {
+ err = WskCmd.GenBashCompletionFile(BASH_AUTOCOMPLETE_FILENAME)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "GenBashCompletionFile('%s`) error: \n", BASH_AUTOCOMPLETE_FILENAME, err)
+ errStr := wski18n.T("Unable to generate '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": BASH_AUTOCOMPLETE_FILENAME, "err": err})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ fmt.Printf(
+ wski18n.T("bash_completion_msg",
+ map[string]interface{}{"name": BASH_AUTOCOMPLETE_FILENAME}))
+ }
+ default:
+ whisk.Debug(whisk.DbgError, "Invalid component argument '%s'\n", component)
+ errStr := wski18n.T("The SDK component argument '{{.component}}' is invalid. Valid components are docker, ios and bashauto",
+ map[string]interface{}{"component": component})
+ err = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ }
- if err != nil {
- return err
- }
- return nil
- },
+ if err != nil {
+ return err
+ }
+ return nil
+ },
}
func dockerInstall() error {
- var err error
+ var err error
- targetFile := sdkMap[SDK_DOCKER_COMPONENT_NAME].FileName
- if _, err = os.Stat(targetFile); err == nil {
- whisk.Debug(whisk.DbgError, "os.Stat reports file '%s' exists\n", targetFile)
- errStr := wski18n.T("The file '{{.name}}' already exists. Delete it and retry.",
- map[string]interface{}{"name": targetFile})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
+ targetFile := sdkMap[SDK_DOCKER_COMPONENT_NAME].FileName
+ if _, err = os.Stat(targetFile); err == nil {
+ whisk.Debug(whisk.DbgError, "os.Stat reports file '%s' exists\n", targetFile)
+ errStr := wski18n.T("The file '{{.name}}' already exists. Delete it and retry.",
+ map[string]interface{}{"name": targetFile})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
- if err = sdkInstall(SDK_DOCKER_COMPONENT_NAME); err != nil {
- whisk.Debug(whisk.DbgError, "sdkInstall(%s) failed: %s\n", SDK_DOCKER_COMPONENT_NAME, err)
- errStr := wski18n.T("The {{.component}} SDK installation failed: {{.err}}",
- map[string]interface{}{"component": SDK_DOCKER_COMPONENT_NAME, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
+ if err = sdkInstall(SDK_DOCKER_COMPONENT_NAME); err != nil {
+ whisk.Debug(whisk.DbgError, "sdkInstall(%s) failed: %s\n", SDK_DOCKER_COMPONENT_NAME, err)
+ errStr := wski18n.T("The {{.component}} SDK installation failed: {{.err}}",
+ map[string]interface{}{"component": SDK_DOCKER_COMPONENT_NAME, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
- fmt.Println(wski18n.T("The docker skeleton is now installed at the current directory."))
- return nil
+ fmt.Println(wski18n.T("The docker skeleton is now installed at the current directory."))
+ return nil
}
func iOSInstall() error {
- var err error
+ var err error
- if err = sdkInstall(SDK_IOS_COMPONENT_NAME); err != nil {
- whisk.Debug(whisk.DbgError, "sdkInstall(%s) failed: %s\n", SDK_IOS_COMPONENT_NAME, err)
- errStr := wski18n.T("The {{.component}} SDK installation failed: {{.err}}",
- map[string]interface{}{"component": SDK_IOS_COMPONENT_NAME, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
+ if err = sdkInstall(SDK_IOS_COMPONENT_NAME); err != nil {
+ whisk.Debug(whisk.DbgError, "sdkInstall(%s) failed: %s\n", SDK_IOS_COMPONENT_NAME, err)
+ errStr := wski18n.T("The {{.component}} SDK installation failed: {{.err}}",
+ map[string]interface{}{"component": SDK_IOS_COMPONENT_NAME, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
- fmt.Printf(
- wski18n.T("Downloaded OpenWhisk iOS starter app. Unzip '{{.name}}' and open the project in Xcode.\n",
- map[string]interface{}{"name": sdkMap[SDK_IOS_COMPONENT_NAME].FileName}))
- return nil
+ fmt.Printf(
+ wski18n.T("Downloaded OpenWhisk iOS starter app. Unzip '{{.name}}' and open the project in Xcode.\n",
+ map[string]interface{}{"name": sdkMap[SDK_IOS_COMPONENT_NAME].FileName}))
+ return nil
}
func sdkInstall(componentName string) error {
- targetFile := sdkMap[componentName].FileName
- if _, err := os.Stat(targetFile); err == nil {
- whisk.Debug(whisk.DbgError, "os.Stat reports file '%s' exists\n", targetFile)
- errStr := wski18n.T("The file '{{.name}}' already exists. Delete it and retry.",
- map[string]interface{}{"name": targetFile})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
+ targetFile := sdkMap[componentName].FileName
+ if _, err := os.Stat(targetFile); err == nil {
+ whisk.Debug(whisk.DbgError, "os.Stat reports file '%s' exists\n", targetFile)
+ errStr := wski18n.T("The file '{{.name}}' already exists. Delete it and retry.",
+ map[string]interface{}{"name": targetFile})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
- resp, err := Client.Sdks.Install(sdkMap[componentName].UrlPath)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Sdks.Install(%s) failed: %s\n", sdkMap[componentName].UrlPath, err)
- errStr := wski18n.T("Unable to retrieve '{{.urlpath}}' SDK: {{.err}}",
- map[string]interface{}{"urlpath": sdkMap[componentName].UrlPath, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
+ resp, err := Client.Sdks.Install(sdkMap[componentName].UrlPath)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Sdks.Install(%s) failed: %s\n", sdkMap[componentName].UrlPath, err)
+ errStr := wski18n.T("Unable to retrieve '{{.urlpath}}' SDK: {{.err}}",
+ map[string]interface{}{"urlpath": sdkMap[componentName].UrlPath, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
- if resp.Body == nil {
- whisk.Debug(whisk.DbgError, "SDK Install HTTP response has no body\n")
- errStr := wski18n.T("Server failed to send the '{{.component}}' SDK: {{.err}}",
- map[string]interface{}{"name": componentName, "err": err})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
+ if resp.Body == nil {
+ whisk.Debug(whisk.DbgError, "SDK Install HTTP response has no body\n")
+ errStr := wski18n.T("Server failed to send the '{{.component}}' SDK: {{.err}}",
+ map[string]interface{}{"name": componentName, "err": err})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
- // Create the SDK file
- sdkfile, err := os.Create(targetFile)
- if err != nil {
- whisk.Debug(whisk.DbgError, "os.Create(%s) failure: %s\n", targetFile, err)
- errStr := wski18n.T("Error creating SDK file '{{.name}}': {{.err}}",
- map[string]interface{}{"name": targetFile, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
+ // Create the SDK file
+ sdkfile, err := os.Create(targetFile)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "os.Create(%s) failure: %s\n", targetFile, err)
+ errStr := wski18n.T("Error creating SDK file '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": targetFile, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
- // Read the HTTP response body and write it to the SDK file
- whisk.Debug(whisk.DbgInfo, "Reading SDK file from HTTP response body\n")
- _, err = io.Copy(sdkfile, resp.Body)
- if err != nil {
- whisk.Debug(whisk.DbgError, "io.Copy() of resp.Body into sdkfile failure: %s\n", err)
- errStr := wski18n.T("Error copying server response into file: {{.err}}",
- map[string]interface{}{"err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- sdkfile.Close()
- return werr
+ // Read the HTTP response body and write it to the SDK file
+ whisk.Debug(whisk.DbgInfo, "Reading SDK file from HTTP response body\n")
+ _, err = io.Copy(sdkfile, resp.Body)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "io.Copy() of resp.Body into sdkfile failure: %s\n", err)
+ errStr := wski18n.T("Error copying server response into file: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ sdkfile.Close()
+ return werr
- }
- sdkfile.Close() // Don't use 'defer' since this file might need to be deleted after unpack
+ }
+ sdkfile.Close() // Don't use 'defer' since this file might need to be deleted after unpack
- // At this point, the entire file is downloaded from the server
- // Check if there is any special post-download processing (i.e. unpack)
- if sdkMap[componentName].Unpack {
- // Make sure the target directory does not already exist
- defer os.Remove(targetFile)
- targetdir := sdkMap[componentName].UnpackDir
- if _, err = os.Stat(targetdir); err == nil {
- whisk.Debug(whisk.DbgError, "os.Stat reports that directory '%s' exists\n", targetdir)
- errStr := wski18n.T("The directory '{{.name}}' already exists. Delete it and retry.",
- map[string]interface{}{"name": targetdir})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
+ // At this point, the entire file is downloaded from the server
+ // Check if there is any special post-download processing (i.e. unpack)
+ if sdkMap[componentName].Unpack {
+ // Make sure the target directory does not already exist
+ defer os.Remove(targetFile)
+ targetdir := sdkMap[componentName].UnpackDir
+ if _, err = os.Stat(targetdir); err == nil {
+ whisk.Debug(whisk.DbgError, "os.Stat reports that directory '%s' exists\n", targetdir)
+ errStr := wski18n.T("The directory '{{.name}}' already exists. Delete it and retry.",
+ map[string]interface{}{"name": targetdir})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
- // If the packed SDK is a .tgz file, unpack it in two steps
- // 1. UnGzip into temp .tar file
- // 2. Untar the contents into the current folder
- if sdkMap[componentName].isGzTar {
- whisk.Debug(whisk.DbgInfo, "unGzipping downloaded file\n")
- err := unpackGzip(targetFile, "temp.tar")
- if err != nil {
- whisk.Debug(whisk.DbgError, "unpackGzip(%s,temp.tar) failure: %s\n", targetFile, err)
- errStr := wski18n.T("Error unGzipping file '{{.name}}': {{.err}}",
- map[string]interface{}{"name": targetFile, "err": err})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- defer os.Remove("temp.tar")
+ // If the packed SDK is a .tgz file, unpack it in two steps
+ // 1. UnGzip into temp .tar file
+ // 2. Untar the contents into the current folder
+ if sdkMap[componentName].isGzTar {
+ whisk.Debug(whisk.DbgInfo, "unGzipping downloaded file\n")
+ err := unpackGzip(targetFile, "temp.tar")
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "unpackGzip(%s,temp.tar) failure: %s\n", targetFile, err)
+ errStr := wski18n.T("Error unGzipping file '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": targetFile, "err": err})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ defer os.Remove("temp.tar")
- whisk.Debug(whisk.DbgInfo, "unTarring unGzipped file\n")
- err = unpackTar("temp.tar")
- if err != nil {
- whisk.Debug(whisk.DbgError, "unpackTar(temp.tar) failure: %s\n", err)
- errStr := wski18n.T("Error untarring file '{{.name}}': {{.err}}",
- map[string]interface{}{"name": "temp.tar", "err": err})
- werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- }
+ whisk.Debug(whisk.DbgInfo, "unTarring unGzipped file\n")
+ err = unpackTar("temp.tar")
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "unpackTar(temp.tar) failure: %s\n", err)
+ errStr := wski18n.T("Error untarring file '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": "temp.tar", "err": err})
+ werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ }
- // Future SDKs may require other unpacking procedures not yet covered here....
- }
+ // Future SDKs may require other unpacking procedures not yet covered here....
+ }
- return nil
+ return nil
}
func init() {
- sdkInstallCmd.Flags().BoolVarP(&Flags.sdk.stdout, "stdout", "s", false, wski18n.T("prints bash command completion script to stdout"))
+ sdkInstallCmd.Flags().BoolVarP(&Flags.sdk.stdout, "stdout", "s", false, wski18n.T("prints bash command completion script to stdout"))
- sdkCmd.AddCommand(sdkInstallCmd)
+ sdkCmd.AddCommand(sdkInstallCmd)
- sdkMap = make(map[string]*sdkInfo)
- sdkMap["docker"] = &sdkInfo{ UrlPath: "blackbox.tar.gz", FileName: "blackbox.tar.gz", isGzTar: true, Unpack: true, UnpackDir: "dockerSkeleton"}
- sdkMap["ios"] = &sdkInfo{ UrlPath: "OpenWhiskIOSStarterApp.zip", FileName: "OpenWhiskIOSStarterApp.zip", IsZip: true, Unpack: false}
+ sdkMap = make(map[string]*sdkInfo)
+ sdkMap["docker"] = &sdkInfo{UrlPath: "blackbox.tar.gz", FileName: "blackbox.tar.gz", isGzTar: true, Unpack: true, UnpackDir: "dockerSkeleton"}
+ sdkMap["ios"] = &sdkInfo{UrlPath: "OpenWhiskIOSStarterApp.zip", FileName: "OpenWhiskIOSStarterApp.zip", IsZip: true, Unpack: false}
}
diff --git a/commands/shared.go b/commands/shared.go
index 5082e05..9295d2b 100644
--- a/commands/shared.go
+++ b/commands/shared.go
@@ -18,27 +18,26 @@
package commands
import (
- "errors"
+ "errors"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
- "github.com/apache/incubator-openwhisk-client-go/whisk"
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
)
-func entityNameError(entityName string) (error) {
- errMsg := wski18n.T(
- "An entity name, '{{.name}}', was provided instead of a namespace. Valid namespaces are of the following format: /NAMESPACE.",
- map[string]interface{}{
- "name": entityName,
- })
+func entityNameError(entityName string) error {
+ errMsg := wski18n.T(
+ "An entity name, '{{.name}}', was provided instead of a namespace. Valid namespaces are of the following format: /NAMESPACE.",
+ map[string]interface{}{
+ "name": entityName,
+ })
- return whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
}
func entityListError(err error, namespace string, kind string) error {
- whisk.Debug(whisk.DbgError, "Client.%s.List(%s) error: %s\n", kind, namespace, err)
- errStr := wski18n.T("Unable to obtain the list of entities for namespace '{{.namespace}}': {{.err}}",
- map[string]interface{}{"namespace": namespace, "err": err})
- return whisk.MakeWskErrorFromWskError(errors.New(errStr), err,
- whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ whisk.Debug(whisk.DbgError, "Client.%s.List(%s) error: %s\n", kind, namespace, err)
+ errStr := wski18n.T("Unable to obtain the list of entities for namespace '{{.namespace}}': {{.err}}",
+ map[string]interface{}{"namespace": namespace, "err": err})
+ return whisk.MakeWskErrorFromWskError(errors.New(errStr), err,
+ whisk.EXIT_CODE_ERR_NETWORK, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
}
-
diff --git a/commands/trigger.go b/commands/trigger.go
index 9f1889c..fb50161 100644
--- a/commands/trigger.go
+++ b/commands/trigger.go
@@ -18,561 +18,560 @@
package commands
import (
- "errors"
- "fmt"
+ "errors"
+ "fmt"
- "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-cli/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/whisk"
- "github.com/spf13/cobra"
- "github.com/fatih/color"
+ "github.com/fatih/color"
+ "github.com/spf13/cobra"
)
-const FEED_LIFECYCLE_EVENT = "lifecycleEvent"
-const FEED_TRIGGER_NAME = "triggerName"
-const FEED_AUTH_KEY = "authKey"
-const FEED_CREATE = "CREATE"
-const FEED_READ = "READ"
-const FEED_UPDATE = "UPDATE"
-const FEED_DELETE = "DELETE"
+const FEED_LIFECYCLE_EVENT = "lifecycleEvent"
+const FEED_TRIGGER_NAME = "triggerName"
+const FEED_AUTH_KEY = "authKey"
+const FEED_CREATE = "CREATE"
+const FEED_READ = "READ"
+const FEED_UPDATE = "UPDATE"
+const FEED_DELETE = "DELETE"
// triggerCmd represents the trigger command
var triggerCmd = &cobra.Command{
- Use: "trigger",
- Short: wski18n.T("work with triggers"),
+ Use: "trigger",
+ Short: wski18n.T("work with triggers"),
}
var triggerFireCmd = &cobra.Command{
- Use: "fire TRIGGER_NAME [PAYLOAD]",
- Short: wski18n.T("fire trigger event"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var parameters interface{}
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 2, "Trigger fire",
- wski18n.T("A trigger name is required. A payload is optional.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- // Add payload to parameters
- if len(args) == 2 {
- Flags.common.param = append(Flags.common.param, getFormattedJSON("payload", args[1]))
- Flags.common.param = append(Flags.common.param, Flags.common.param...)
- }
-
- if len(Flags.common.param) > 0 {
- parameters, err = getJSONFromStrings(Flags.common.param, false)
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, false) failed: %s\n", Flags.common.param, err)
- errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
- map[string]interface{}{"param": fmt.Sprintf("%#v",Flags.common.param), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
- }
-
- trigResp, _, err := Client.Triggers.Fire(qualifiedName.GetEntityName(), parameters)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Triggers.Fire(%s, %#v) failed: %s\n", qualifiedName.GetEntityName(), parameters, err)
- errStr := wski18n.T("Unable to fire trigger '{{.name}}': {{.err}}",
- map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} triggered /{{.namespace}}/{{.name}} with id {{.id}}\n",
- map[string]interface{}{
- "ok": color.GreenString("ok:"),
- "namespace": boldString(qualifiedName.GetNamespace()),
- "name": boldString(qualifiedName.GetEntityName()),
- "id": boldString(trigResp.ActivationId)}))
- return nil
- },
+ Use: "fire TRIGGER_NAME [PAYLOAD]",
+ Short: wski18n.T("fire trigger event"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var parameters interface{}
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 2, "Trigger fire",
+ wski18n.T("A trigger name is required. A payload is optional.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ // Add payload to parameters
+ if len(args) == 2 {
+ Flags.common.param = append(Flags.common.param, getFormattedJSON("payload", args[1]))
+ Flags.common.param = append(Flags.common.param, Flags.common.param...)
+ }
+
+ if len(Flags.common.param) > 0 {
+ parameters, err = getJSONFromStrings(Flags.common.param, false)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, false) failed: %s\n", Flags.common.param, err)
+ errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
+ map[string]interface{}{"param": fmt.Sprintf("%#v", Flags.common.param), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+ }
+
+ trigResp, _, err := Client.Triggers.Fire(qualifiedName.GetEntityName(), parameters)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Triggers.Fire(%s, %#v) failed: %s\n", qualifiedName.GetEntityName(), parameters, err)
+ errStr := wski18n.T("Unable to fire trigger '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} triggered /{{.namespace}}/{{.name}} with id {{.id}}\n",
+ map[string]interface{}{
+ "ok": color.GreenString("ok:"),
+ "namespace": boldString(qualifiedName.GetNamespace()),
+ "name": boldString(qualifiedName.GetEntityName()),
+ "id": boldString(trigResp.ActivationId)}))
+ return nil
+ },
}
var triggerCreateCmd = &cobra.Command{
- Use: "create TRIGGER_NAME",
- Short: wski18n.T("create new trigger"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var annotations interface{}
- var feedArgPassed bool = (Flags.common.feed != "")
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Trigger create",
- wski18n.T("A trigger name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- var fullTriggerName string
- var fullFeedName string
- var feedQualifiedName = new(QualifiedName)
- if feedArgPassed {
- whisk.Debug(whisk.DbgInfo, "Trigger has a feed\n")
-
- if feedQualifiedName, err = NewQualifiedName(Flags.common.feed); err != nil {
- return NewQualifiedNameError(Flags.common.feed, err)
- }
-
- fullFeedName = fmt.Sprintf("/%s/%s", feedQualifiedName.GetNamespace(), feedQualifiedName.GetEntityName())
- fullTriggerName = fmt.Sprintf("/%s/%s", qualifiedName.GetNamespace(), qualifiedName.GetEntityName())
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_LIFECYCLE_EVENT, FEED_CREATE))
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_TRIGGER_NAME, fullTriggerName))
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_AUTH_KEY, Client.Config.AuthToken))
- }
-
-
- // Convert the trigger's list of default parameters from a string into []KeyValue
- // The 1 or more --param arguments have all been combined into a single []string
- // e.g. --p arg1,arg2 --p arg3,arg4 -> [arg1, arg2, arg3, arg4]
- whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
- parameters, err := getJSONFromStrings(Flags.common.param, !feedArgPassed)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
- errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
- map[string]interface{}{"param": fmt.Sprintf("%#v",Flags.common.param), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- // Add feed to annotations
- if feedArgPassed {
- Flags.common.annotation = append(Flags.common.annotation, getFormattedJSON("feed", Flags.common.feed))
- }
-
- whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
- annotations, err = getJSONFromStrings(Flags.common.annotation, true)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
- errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
- map[string]interface{}{"annotation": fmt.Sprintf("%#v",Flags.common.annotation), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- trigger := &whisk.Trigger{
- Name: qualifiedName.GetEntityName(),
- Annotations: annotations.(whisk.KeyValueArr),
- }
-
- if !feedArgPassed {
- trigger.Parameters = parameters.(whisk.KeyValueArr)
- }
-
- _, _, err = Client.Triggers.Insert(trigger, false)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Triggers.Insert(%+v,false) failed: %s\n", trigger, err)
- errStr := wski18n.T("Unable to create trigger '{{.name}}': {{.err}}",
- map[string]interface{}{"name": trigger.Name, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- // Invoke the specified feed action to configure the trigger feed
- if feedArgPassed {
- err := configureFeed(trigger.Name, fullFeedName)
- if err != nil {
- whisk.Debug(whisk.DbgError, "configureFeed(%s, %s) failed: %s\n", trigger.Name, Flags.common.feed,
- err)
- errStr := wski18n.T("Unable to create trigger '{{.name}}': {{.err}}",
- map[string]interface{}{"name": trigger.Name, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
-
- // Delete trigger that was created for this feed
- delerr := deleteTrigger(args[0])
- if delerr != nil {
- whisk.Debug(whisk.DbgWarn, "Ignoring deleteTrigger(%s) failure: %s\n", args[0], delerr)
- }
- return werr
- }
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} created trigger {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(trigger.Name)}))
- return nil
- },
+ Use: "create TRIGGER_NAME",
+ Short: wski18n.T("create new trigger"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var annotations interface{}
+ var feedArgPassed bool = (Flags.common.feed != "")
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Trigger create",
+ wski18n.T("A trigger name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ var fullTriggerName string
+ var fullFeedName string
+ var feedQualifiedName = new(QualifiedName)
+ if feedArgPassed {
+ whisk.Debug(whisk.DbgInfo, "Trigger has a feed\n")
+
+ if feedQualifiedName, err = NewQualifiedName(Flags.common.feed); err != nil {
+ return NewQualifiedNameError(Flags.common.feed, err)
+ }
+
+ fullFeedName = fmt.Sprintf("/%s/%s", feedQualifiedName.GetNamespace(), feedQualifiedName.GetEntityName())
+ fullTriggerName = fmt.Sprintf("/%s/%s", qualifiedName.GetNamespace(), qualifiedName.GetEntityName())
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_LIFECYCLE_EVENT, FEED_CREATE))
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_TRIGGER_NAME, fullTriggerName))
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_AUTH_KEY, Client.Config.AuthToken))
+ }
+
+ // Convert the trigger's list of default parameters from a string into []KeyValue
+ // The 1 or more --param arguments have all been combined into a single []string
+ // e.g. --p arg1,arg2 --p arg3,arg4 -> [arg1, arg2, arg3, arg4]
+ whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
+ parameters, err := getJSONFromStrings(Flags.common.param, !feedArgPassed)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
+ errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
+ map[string]interface{}{"param": fmt.Sprintf("%#v", Flags.common.param), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ // Add feed to annotations
+ if feedArgPassed {
+ Flags.common.annotation = append(Flags.common.annotation, getFormattedJSON("feed", Flags.common.feed))
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
+ annotations, err = getJSONFromStrings(Flags.common.annotation, true)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
+ errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
+ map[string]interface{}{"annotation": fmt.Sprintf("%#v", Flags.common.annotation), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ trigger := &whisk.Trigger{
+ Name: qualifiedName.GetEntityName(),
+ Annotations: annotations.(whisk.KeyValueArr),
+ }
+
+ if !feedArgPassed {
+ trigger.Parameters = parameters.(whisk.KeyValueArr)
+ }
+
+ _, _, err = Client.Triggers.Insert(trigger, false)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Triggers.Insert(%+v,false) failed: %s\n", trigger, err)
+ errStr := wski18n.T("Unable to create trigger '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": trigger.Name, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ // Invoke the specified feed action to configure the trigger feed
+ if feedArgPassed {
+ err := configureFeed(trigger.Name, fullFeedName)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "configureFeed(%s, %s) failed: %s\n", trigger.Name, Flags.common.feed,
+ err)
+ errStr := wski18n.T("Unable to create trigger '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": trigger.Name, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+
+ // Delete trigger that was created for this feed
+ delerr := deleteTrigger(args[0])
+ if delerr != nil {
+ whisk.Debug(whisk.DbgWarn, "Ignoring deleteTrigger(%s) failure: %s\n", args[0], delerr)
+ }
+ return werr
+ }
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} created trigger {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(trigger.Name)}))
+ return nil
+ },
}
var triggerUpdateCmd = &cobra.Command{
- Use: "update TRIGGER_NAME",
- Short: wski18n.T("update an existing trigger, or create a trigger if it does not exist"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var fullFeedName string
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Trigger update",
- wski18n.T("A trigger name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- // Convert the trigger's list of default parameters from a string into []KeyValue
- // The 1 or more --param arguments have all been combined into a single []string
- // e.g. --p arg1,arg2 --p arg3,arg4 -> [arg1, arg2, arg3, arg4]
-
- whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
- parameters, err := getJSONFromStrings(Flags.common.param, true)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
- errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
- map[string]interface{}{"param": fmt.Sprintf("%#v",Flags.common.param), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
- annotations, err := getJSONFromStrings(Flags.common.annotation, true)
-
- if err != nil {
- whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
- errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
- map[string]interface{}{"annotation": fmt.Sprintf("%#v",Flags.common.annotation), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
- return werr
- }
-
- retTrigger, _, err := Client.Triggers.Get(qualifiedName.GetEntityName())
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Triggers.Get(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
- errStr := wski18n.T("Unable to get trigger '{{.name}}': {{.err}}",
- map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- // Get full feed name from trigger get request as it is needed to get the feed
- if retTrigger != nil && retTrigger.Annotations != nil {
- fullFeedName = getValueString(retTrigger.Annotations, "feed")
- }
-
- if len(fullFeedName) > 0 {
- fullTriggerName := fmt.Sprintf("/%s/%s", qualifiedName.GetNamespace(), qualifiedName.GetEntityName())
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_LIFECYCLE_EVENT, FEED_UPDATE))
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_TRIGGER_NAME, fullTriggerName))
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_AUTH_KEY, Client.Config.AuthToken))
-
- // Invoke the specified feed action to configure the trigger feed
- err = configureFeed(qualifiedName.GetEntityName(), fullFeedName)
- if err != nil {
- whisk.Debug(whisk.DbgError, "configureFeed(%s, %s) failed: %s\n", qualifiedName.GetEntityName(), Flags.common.feed,
- err)
- errStr := wski18n.T("Unable to create trigger '{{.name}}': {{.err}}",
- map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- } else {
- trigger := &whisk.Trigger{
- Name: qualifiedName.GetEntityName(),
- Parameters: parameters.(whisk.KeyValueArr),
- Annotations: annotations.(whisk.KeyValueArr),
- }
-
- _, _, err = Client.Triggers.Insert(trigger, true)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Triggers.Insert(%+v,true) failed: %s\n", trigger, err)
- errStr := wski18n.T("Unable to update trigger '{{.name}}': {{.err}}",
- map[string]interface{}{"name": trigger.Name, "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} updated trigger {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
- return nil
- },
+ Use: "update TRIGGER_NAME",
+ Short: wski18n.T("update an existing trigger, or create a trigger if it does not exist"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var fullFeedName string
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Trigger update",
+ wski18n.T("A trigger name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ // Convert the trigger's list of default parameters from a string into []KeyValue
+ // The 1 or more --param arguments have all been combined into a single []string
+ // e.g. --p arg1,arg2 --p arg3,arg4 -> [arg1, arg2, arg3, arg4]
+
+ whisk.Debug(whisk.DbgInfo, "Parsing parameters: %#v\n", Flags.common.param)
+ parameters, err := getJSONFromStrings(Flags.common.param, true)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.param, err)
+ errStr := wski18n.T("Invalid parameter argument '{{.param}}': {{.err}}",
+ map[string]interface{}{"param": fmt.Sprintf("%#v", Flags.common.param), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ whisk.Debug(whisk.DbgInfo, "Parsing annotations: %#v\n", Flags.common.annotation)
+ annotations, err := getJSONFromStrings(Flags.common.annotation, true)
+
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "getJSONFromStrings(%#v, true) failed: %s\n", Flags.common.annotation, err)
+ errStr := wski18n.T("Invalid annotation argument '{{.annotation}}': {{.err}}",
+ map[string]interface{}{"annotation": fmt.Sprintf("%#v", Flags.common.annotation), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
+ return werr
+ }
+
+ retTrigger, _, err := Client.Triggers.Get(qualifiedName.GetEntityName())
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Triggers.Get(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
+ errStr := wski18n.T("Unable to get trigger '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ // Get full feed name from trigger get request as it is needed to get the feed
+ if retTrigger != nil && retTrigger.Annotations != nil {
+ fullFeedName = getValueString(retTrigger.Annotations, "feed")
+ }
+
+ if len(fullFeedName) > 0 {
+ fullTriggerName := fmt.Sprintf("/%s/%s", qualifiedName.GetNamespace(), qualifiedName.GetEntityName())
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_LIFECYCLE_EVENT, FEED_UPDATE))
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_TRIGGER_NAME, fullTriggerName))
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_AUTH_KEY, Client.Config.AuthToken))
+
+ // Invoke the specified feed action to configure the trigger feed
+ err = configureFeed(qualifiedName.GetEntityName(), fullFeedName)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "configureFeed(%s, %s) failed: %s\n", qualifiedName.GetEntityName(), Flags.common.feed,
+ err)
+ errStr := wski18n.T("Unable to create trigger '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ } else {
+ trigger := &whisk.Trigger{
+ Name: qualifiedName.GetEntityName(),
+ Parameters: parameters.(whisk.KeyValueArr),
+ Annotations: annotations.(whisk.KeyValueArr),
+ }
+
+ _, _, err = Client.Triggers.Insert(trigger, true)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Triggers.Insert(%+v,true) failed: %s\n", trigger, err)
+ errStr := wski18n.T("Unable to update trigger '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": trigger.Name, "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} updated trigger {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
+ return nil
+ },
}
var triggerGetCmd = &cobra.Command{
- Use: "get TRIGGER_NAME [FIELD_FILTER]",
- Short: wski18n.T("get trigger"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var field string
- var fullFeedName string
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 2, "Trigger get", wski18n.T("A trigger name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if len(args) > 1 {
- field = args[1]
-
- if !fieldExists(&whisk.Trigger{}, field) {
- errMsg := wski18n.T("Invalid field filter '{{.arg}}'.", map[string]interface{}{"arg": field})
- whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
- whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return whiskErr
- }
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- retTrigger, _, err := Client.Triggers.Get(qualifiedName.GetEntityName())
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Triggers.Get(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
- errStr := wski18n.T("Unable to get trigger '{{.name}}': {{.err}}",
- map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- // Get full feed name from trigger get request as it is needed to get the feed
- if retTrigger != nil && retTrigger.Annotations != nil {
- fullFeedName = getValueString(retTrigger.Annotations, "feed")
- }
-
- if len(fullFeedName) > 0 {
- fullTriggerName := fmt.Sprintf("/%s/%s", qualifiedName.GetNamespace(), qualifiedName.GetEntityName())
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_LIFECYCLE_EVENT, FEED_READ))
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_TRIGGER_NAME, fullTriggerName))
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_AUTH_KEY, Client.Config.AuthToken))
-
- err = configureFeed(qualifiedName.GetEntityName(), fullFeedName)
- if err != nil {
- whisk.Debug(whisk.DbgError, "configureFeed(%s, %s) failed: %s\n", qualifiedName.GetEntityName(), fullFeedName, err)
- }
- } else {
- if (Flags.trigger.summary) {
- printSummary(retTrigger)
- } else {
- if len(field) > 0 {
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got trigger {{.name}}, displaying field {{.field}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName()),
- "field": boldString(field)}))
- printField(retTrigger, field)
- } else {
- fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got trigger {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
- printJSON(retTrigger)
- }
- }
- }
-
- return nil
- },
+ Use: "get TRIGGER_NAME [FIELD_FILTER]",
+ Short: wski18n.T("get trigger"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var field string
+ var fullFeedName string
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 2, "Trigger get", wski18n.T("A trigger name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if len(args) > 1 {
+ field = args[1]
+
+ if !fieldExists(&whisk.Trigger{}, field) {
+ errMsg := wski18n.T("Invalid field filter '{{.arg}}'.", map[string]interface{}{"arg": field})
+ whiskErr := whisk.MakeWskError(errors.New(errMsg), whisk.EXIT_CODE_ERR_GENERAL,
+ whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ retTrigger, _, err := Client.Triggers.Get(qualifiedName.GetEntityName())
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Triggers.Get(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
+ errStr := wski18n.T("Unable to get trigger '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ // Get full feed name from trigger get request as it is needed to get the feed
+ if retTrigger != nil && retTrigger.Annotations != nil {
+ fullFeedName = getValueString(retTrigger.Annotations, "feed")
+ }
+
+ if len(fullFeedName) > 0 {
+ fullTriggerName := fmt.Sprintf("/%s/%s", qualifiedName.GetNamespace(), qualifiedName.GetEntityName())
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_LIFECYCLE_EVENT, FEED_READ))
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_TRIGGER_NAME, fullTriggerName))
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_AUTH_KEY, Client.Config.AuthToken))
+
+ err = configureFeed(qualifiedName.GetEntityName(), fullFeedName)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "configureFeed(%s, %s) failed: %s\n", qualifiedName.GetEntityName(), fullFeedName, err)
+ }
+ } else {
+ if Flags.trigger.summary {
+ printSummary(retTrigger)
+ } else {
+ if len(field) > 0 {
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got trigger {{.name}}, displaying field {{.field}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName()),
+ "field": boldString(field)}))
+ printField(retTrigger, field)
+ } else {
+ fmt.Fprintf(color.Output, wski18n.T("{{.ok}} got trigger {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
+ printJSON(retTrigger)
+ }
+ }
+ }
+
+ return nil
+ },
}
var triggerDeleteCmd = &cobra.Command{
- Use: "delete TRIGGER_NAME",
- Short: wski18n.T("delete trigger"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var retTrigger *whisk.Trigger
- var fullFeedName string
- var origParams []string
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 1, 1, "Trigger delete",
- wski18n.T("A trigger name is required.")); whiskErr != nil {
- return whiskErr
- }
-
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
-
- retTrigger, _, err = Client.Triggers.Get(qualifiedName.GetEntityName())
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Triggers.Get(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
- errStr := wski18n.T("Unable to get trigger '{{.name}}': {{.err}}",
- map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- // Get full feed name from trigger delete request as it is needed to delete the feed
- if retTrigger != nil && retTrigger.Annotations != nil {
- fullFeedName = getValueString(retTrigger.Annotations, "feed")
-
- if len(fullFeedName) > 0 {
- origParams = Flags.common.param
- fullTriggerName := fmt.Sprintf("/%s/%s", qualifiedName.GetNamespace(), qualifiedName.GetEntityName())
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_LIFECYCLE_EVENT, FEED_DELETE))
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_TRIGGER_NAME, fullTriggerName))
- Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_AUTH_KEY, Client.Config.AuthToken))
-
- err = configureFeed(qualifiedName.GetEntityName(), fullFeedName)
- if err != nil {
- whisk.Debug(whisk.DbgError, "configureFeed(%s, %s) failed: %s\n", qualifiedName.GetEntityName(), fullFeedName, err)
- }
-
- Flags.common.param = origParams
- Client.Namespace = qualifiedName.GetNamespace()
- }
-
- }
-
- retTrigger, _, err = Client.Triggers.Delete(qualifiedName.GetEntityName())
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Triggers.Delete(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
- errStr := wski18n.T("Unable to delete trigger '{{.name}}': {{.err}}",
- map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
-
- fmt.Fprintf(color.Output,
- wski18n.T("{{.ok}} deleted trigger {{.name}}\n",
- map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
-
- return nil
- },
+ Use: "delete TRIGGER_NAME",
+ Short: wski18n.T("delete trigger"),
+ SilenceUsage: true,
+ SilenceErrors: true,
+ PreRunE: SetupClientConfig,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var err error
+ var retTrigger *whisk.Trigger
+ var fullFeedName string
+ var origParams []string
+ var qualifiedName = new(QualifiedName)
+
+ if whiskErr := CheckArgs(args, 1, 1, "Trigger delete",
+ wski18n.T("A trigger name is required.")); whiskErr != nil {
+ return whiskErr
+ }
+
+ if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
+ return NewQualifiedNameError(args[0], err)
+ }
+
+ Client.Namespace = qualifiedName.GetNamespace()
+
+ retTrigger, _, err = Client.Triggers.Get(qualifiedName.GetEntityName())
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Triggers.Get(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
+ errStr := wski18n.T("Unable to get trigger '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ // Get full feed name from trigger delete request as it is needed to delete the feed
+ if retTrigger != nil && retTrigger.Annotations != nil {
+ fullFeedName = getValueString(retTrigger.Annotations, "feed")
+
+ if len(fullFeedName) > 0 {
+ origParams = Flags.common.param
+ fullTriggerName := fmt.Sprintf("/%s/%s", qualifiedName.GetNamespace(), qualifiedName.GetEntityName())
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_LIFECYCLE_EVENT, FEED_DELETE))
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_TRIGGER_NAME, fullTriggerName))
+ Flags.common.param = append(Flags.common.param, getFormattedJSON(FEED_AUTH_KEY, Client.Config.AuthToken))
+
+ err = configureFeed(qualifiedName.GetEntityName(), fullFeedName)
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "configureFeed(%s, %s) failed: %s\n", qualifiedName.GetEntityName(), fullFeedName, err)
+ }
+
+ Flags.common.param = origParams
+ Client.Namespace = qualifiedName.GetNamespace()
+ }
+
+ }
+
+ retTrigger, _, err = Client.Triggers.Delete(qualifiedName.GetEntityName())
+ if err != nil {
+ whisk.Debug(whisk.DbgError, "Client.Triggers.Delete(%s) failed: %s\n", qualifiedName.GetEntityName(), err)
+ errStr := wski18n.T("Unable to delete trigger '{{.name}}': {{.err}}",
+ map[string]interface{}{"name": qualifiedName.GetEntityName(), "err": err})
+ werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
+ return werr
+ }
+
+ fmt.Fprintf(color.Output,
+ wski18n.T("{{.ok}} deleted trigger {{.name}}\n",
+ map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(qualifiedName.GetEntityName())}))
+
+ return nil
+ },
}
var triggerListCmd = &cobra.Command{
- Use: "list [NAMESPACE]",
- Short: wski18n.T("list all triggers"),
- SilenceUsage: true,
- SilenceErrors: true,
- PreRunE: SetupClientConfig,
- RunE: func(cmd *cobra.Command, args []string) error {
- var err error
- var qualifiedName = new(QualifiedName)
-
- if whiskErr := CheckArgs(args, 0, 1, "Trigger list",
- wski18n.T("An optional namespace is the only valid argument.")); whiskErr != nil {
- return whiskErr
- }
-
- if len(args) == 1 {
- if qualifiedName, err = NewQualifiedName(args[0]); err != nil {
- return NewQualifiedNameError(args[0], err)
- }
-
- if len(qualifiedName.GetEntityName()) > 0 {
- return entityNameError(qualifiedName.GetEntityName())
- }
-
- Client.Namespace = qualifiedName.GetNamespace()
- }
-
- options := &whisk.TriggerListOptions{
- Skip: Flags.common.skip,
- Limit: Flags.common.limit,
- }
- triggers, _, err := Client.Triggers.List(options)
- if err != nil {
- whisk.Debug(whisk.DbgError, "Client.Triggers.List(%#v) for namespace '%s' failed: %s\n", options,
- Client.Namespace, err)
- errStr := wski18n.T("Unable to obtain the list of triggers for namespace '{{.name}}': {{.err}}",
- map[string]interface{}{"name": getClientNamespace(), "err": err})
- werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
- return werr
- }
- sortByName := Flags.common.nameSort
- printList(triggers, sortByName)
- return nil
- },
+ Use: "list [NAMESPACE]",
+ Short: wski18n.T("list all triggers"),
+ SilenceUsage: true,
... 2359 lines suppressed ...
--
To stop receiving notification emails like this one, please contact
csantanapr@apache.org.