houshengbo closed pull request #626: Streamline custom error types.
URL: https://github.com/apache/incubator-openwhisk-wskdeploy/pull/626
 
 
   

This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:

As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):

diff --git a/deployers/filesystemreader.go b/deployers/filesystemreader.go
index 7937939..0635bc5 100644
--- a/deployers/filesystemreader.go
+++ b/deployers/filesystemreader.go
@@ -56,7 +56,7 @@ func (reader *FileSystemReader) ReadProjectDirectory(manifest 
*parsers.YAML) ([]
                if fpath != reader.serviceDeployer.ProjectPath {
                        pathCount, err := reader.getFilePathCount(fpath)
             if err != nil {
-                return utils.NewInputYamlFileError(err.Error())
+                return utils.NewYAMLFileReadError(err.Error())
             }
 
                        if !f.IsDir() {
@@ -76,7 +76,7 @@ func (reader *FileSystemReader) ReadProjectDirectory(manifest 
*parsers.YAML) ([]
                                        if foundFile == true {
                                                _, action, err := 
reader.CreateActionFromFile(reader.serviceDeployer.ManifestPath, fpath)
                         if err != nil {
-                            return utils.NewInputYamlFileError(err.Error())
+                            return utils.NewYAMLFileReadError(err.Error())
                         }
 
                                                var record utils.ActionRecord
@@ -127,7 +127,7 @@ func (reader *FileSystemReader) 
CreateActionFromFile(manipath, filePath string)
 
                dat, err := 
new(utils.ContentReader).LocalReader.ReadLocal(filePath)
         if err != nil {
-            return name, action, utils.NewInputYamlFileError(err.Error())
+            return name, action, utils.NewYAMLFileReadError(err.Error())
         }
 
                action.Exec = new(whisk.Exec)
diff --git a/deployers/manifestreader.go b/deployers/manifestreader.go
index d94cfee..6fc6369 100644
--- a/deployers/manifestreader.go
+++ b/deployers/manifestreader.go
@@ -47,7 +47,7 @@ func (deployer *ManifestReader) ParseManifest() 
(*parsers.YAML, *parsers.YAMLPar
        manifest, err := manifestParser.ParseManifest(dep.ManifestPath)
 
        if err != nil {
-               return manifest, manifestParser, 
utils.NewInputYamlFileError(err.Error())
+               return manifest, manifestParser, 
utils.NewYAMLFileReadError(err.Error())
        }
        return manifest, manifestParser, nil
 }
@@ -55,7 +55,7 @@ func (deployer *ManifestReader) ParseManifest() 
(*parsers.YAML, *parsers.YAMLPar
 func (reader *ManifestReader) InitRootPackage(manifestParser 
*parsers.YAMLParser, manifest *parsers.YAML) error {
        packages, err := manifestParser.ComposeAllPackages(manifest, 
reader.serviceDeployer.ManifestPath)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
        reader.SetPackage(packages)
 
@@ -68,62 +68,62 @@ func (deployer *ManifestReader) HandleYaml(sdeployer 
*ServiceDeployer, manifestP
        var err error
        deps, err := 
manifestParser.ComposeDependenciesFromAllPackages(manifest, 
deployer.serviceDeployer.ProjectPath, deployer.serviceDeployer.ManifestPath)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        actions, err := manifestParser.ComposeActionsFromAllPackages(manifest, 
deployer.serviceDeployer.ManifestPath)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        sequences, err := 
manifestParser.ComposeSequencesFromAllPackages(deployer.serviceDeployer.ClientConfig.Namespace,
 manifest)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        triggers, err := 
manifestParser.ComposeTriggersFromAllPackages(manifest, 
deployer.serviceDeployer.ManifestPath)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        rules, err := manifestParser.ComposeRulesFromAllPackages(manifest)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        apis, err := manifestParser.ComposeApiRecordsFromAllPackages(manifest)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        err = deployer.SetDependencies(deps)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        err = deployer.SetActions(actions)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        err = deployer.SetSequences(sequences)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        err = deployer.SetTriggers(triggers)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        err = deployer.SetRules(rules)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        err = deployer.SetApis(apis)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        return nil
@@ -143,7 +143,7 @@ func (reader *ManifestReader) SetDependencies(deps 
map[string]utils.DependencyRe
                                gitReader := utils.NewGitReader(depName, dep)
                                err := gitReader.CloneDependency()
                                if err != nil {
-                                       return 
utils.NewInputYamlFormatError(err.Error())
+                                       return 
utils.NewYAMLFormatError(err.Error())
                                }
                        } else {
                                // TODO: we should do a check to make sure this 
dependency is compatible with an already installed one.
@@ -226,7 +226,7 @@ func (reader *ManifestReader) SetActions(actions 
[]utils.ActionRecord) error {
 
                                err := reader.checkAction(existAction)
                                if err != nil {
-                                       return 
utils.NewInputYamlFormatError(err.Error())
+                                       return 
utils.NewYAMLFormatError(err.Error())
                                }
 
                        } else {
@@ -237,7 +237,7 @@ func (reader *ManifestReader) SetActions(actions 
[]utils.ActionRecord) error {
                        // not a new action so update the action in the package
                        err := reader.checkAction(manifestAction)
                        if err != nil {
-                               return 
utils.NewInputYamlFormatError(err.Error())
+                               return utils.NewYAMLFormatError(err.Error())
                        }
                        
reader.serviceDeployer.Deployment.Packages[manifestAction.Packagename].Actions[manifestAction.Action.Name]
 = manifestAction
                }
@@ -295,7 +295,7 @@ func (reader *ManifestReader) SetSequences(actions 
[]utils.ActionRecord) error {
                        // not a new action so update the action in the package
                        err := reader.checkAction(seqAction)
                        if err != nil {
-                               return 
utils.NewInputYamlFormatError(err.Error())
+                               return utils.NewYAMLFormatError(err.Error())
                        }
                        
reader.serviceDeployer.Deployment.Packages[seqAction.Packagename].Sequences[seqAction.Action.Name]
 = seqAction
                }
diff --git a/deployers/servicedeployer.go b/deployers/servicedeployer.go
index 8bc8b64..15ce427 100644
--- a/deployers/servicedeployer.go
+++ b/deployers/servicedeployer.go
@@ -172,7 +172,7 @@ func (deployer *ServiceDeployer) ConstructDeploymentPlan() 
error {
                                errorString := wski18n.T("The name of the 
project/application {{.projectNameDeploy}} in deployment file at 
[{{.deploymentFile}}] does not match the name of the project/application 
{{.projectNameManifest}}} in manifest file at [{{.manifestFile}}].",
                                        
map[string]interface{}{"projectNameDeploy": projectNameDeploy, 
"deploymentFile": deployer.DeploymentPath,
                                                "projectNameManifest": 
projectName, "manifestFile": deployer.ManifestPath})
-                               return 
utils.NewInputYamlFormatError(errorString)
+                               return utils.NewYAMLFormatError(errorString)
                        }
                }
                deploymentReader.BindAssets()
@@ -233,6 +233,7 @@ func (deployer *ServiceDeployer) 
ConstructUnDeploymentPlan() (*DeploymentProject
                if err != nil {
                        return deployer.Deployment, err
                }
+
                // (TODO) delete this warning after deprecating application in 
deployment file
                if deploymentReader.DeploymentDescriptor.Application.Name != "" 
{
                        warningString := wski18n.T("WARNING: application in 
deployment file will soon be deprecated, please use project instead.\n")
@@ -245,9 +246,10 @@ func (deployer *ServiceDeployer) 
ConstructUnDeploymentPlan() (*DeploymentProject
                                errorString := wski18n.T("The name of the 
project/application {{.projectNameDeploy}} in deployment file at 
[{{.deploymentFile}}] does not match the name of the application 
{{.projectNameManifest}}} in manifest file at [{{.manifestFile}}].",
                                        
map[string]interface{}{"projectNameDeploy": projectNameDeploy, 
"deploymentFile": deployer.DeploymentPath,
                                                "projectNameManifest": 
projectName, "manifestFile": deployer.ManifestPath})
-                               return deployer.Deployment, 
utils.NewInputYamlFormatError(errorString)
+                               return deployer.Deployment, 
utils.NewYAMLFormatError(errorString)
                        }
                }
+
                deploymentReader.BindAssets()
        }
 
diff --git a/deployers/whiskclient.go b/deployers/whiskclient.go
index b0eac7c..92d66fc 100644
--- a/deployers/whiskclient.go
+++ b/deployers/whiskclient.go
@@ -234,7 +234,7 @@ func NewWhiskConfig(proppath string, deploymentPath string, 
manifestPath string,
 
                }
                whisk.Debug(whisk.DbgError, errStr)
-               return clientConfig, utils.NewInvalidWskpropsError(errStr)
+               return clientConfig, 
utils.NewWhiskClientInvalidConfigError(errStr)
        }
 
        stdout := wski18n.T("The API host is {{.apihost}}, from 
{{.apisource}}.\n",
diff --git a/parsers/deploy_parser.go b/parsers/deploy_parser.go
index 31ad115..2df7670 100644
--- a/parsers/deploy_parser.go
+++ b/parsers/deploy_parser.go
@@ -45,12 +45,12 @@ func (dm *YAMLParser) ParseDeployment(deploymentPath 
string) (*YAML, error) {
        dplyyaml := YAML{}
        content, err := 
new(utils.ContentReader).LocalReader.ReadLocal(deploymentPath)
     if err != nil {
-        return &dplyyaml, utils.NewInputYamlFileError(err.Error())
+        return &dplyyaml, utils.NewYAMLFileReadError(err.Error())
     }
        err = dm.UnmarshalDeployment(content, &dplyyaml)
     if err != nil {
         lines, msgs := dm.convertErrorToLinesMsgs(err.Error())
-        return &dplyyaml, utils.NewParserErr(deploymentPath, lines, msgs)
+        return &dplyyaml, utils.NewYAMLParserErr(deploymentPath, lines, msgs)
     }
        dplyyaml.Filepath = deploymentPath
     dplyyamlEnvVar := ReadEnvVariable(&dplyyaml)
diff --git a/parsers/manifest_parser.go b/parsers/manifest_parser.go
index 5aa98e7..771b4f7 100644
--- a/parsers/manifest_parser.go
+++ b/parsers/manifest_parser.go
@@ -41,7 +41,7 @@ func ReadOrCreateManifest() (*YAML, error) {
                dat, _ := ioutil.ReadFile(utils.ManifestFileNameYaml)
                err := NewYAMLParser().Unmarshal(dat, &maniyaml)
                if err != nil {
-                       return &maniyaml, 
utils.NewInputYamlFileError(err.Error())
+                       return &maniyaml, 
utils.NewYAMLFileReadError(err.Error())
                }
        }
        return &maniyaml, nil
@@ -51,12 +51,12 @@ func ReadOrCreateManifest() (*YAML, error) {
 func Write(manifest *YAML, filename string) error {
        output, err := NewYAMLParser().Marshal(manifest)
        if err != nil {
-               return utils.NewInputYamlFormatError(err.Error())
+               return utils.NewYAMLFormatError(err.Error())
        }
 
        f, err := os.Create(filename)
        if err != nil {
-               return utils.NewInputYamlFileError(err.Error())
+               return utils.NewYAMLFileReadError(err.Error())
        }
        defer f.Close()
 
@@ -87,16 +87,16 @@ func (dm *YAMLParser) ParseManifest(manifestPath string) 
(*YAML, error) {
 
        content, err := utils.Read(manifestPath)
        if err != nil {
-               return &maniyaml, utils.NewInputYamlFileError(err.Error())
+               return &maniyaml, utils.NewYAMLFileReadError(err.Error())
        }
 
        err = mm.Unmarshal(content, &maniyaml)
        if err != nil {
                lines, msgs := dm.convertErrorToLinesMsgs(err.Error())
-               return &maniyaml, utils.NewParserErr(manifestPath, lines, msgs)
+               return &maniyaml, utils.NewYAMLParserErr(manifestPath, lines, 
msgs)
        }
        maniyaml.Filepath = manifestPath
-    manifest := ReadEnvVariable(&maniyaml)
+       manifest := ReadEnvVariable(&maniyaml)
 
        return manifest, nil
 }
@@ -361,8 +361,8 @@ func (dm *YAMLParser) 
ComposeActionsFromAllPackages(manifest *YAML, filePath str
                } else {
                        manifestPackages = manifest.GetProject().Packages
                }
-       }
-       for n, p := range manifestPackages {
+       }
+       for n, p := range manifestPackages {
                a, err := dm.ComposeActions(filePath, p.Actions, n)
                if err == nil {
                        s1 = append(s1, a...)
@@ -431,7 +431,7 @@ func (dm *YAMLParser) ComposeActions(filePath string, 
actions map[string]Action,
                                        kind = "nodejs:6"
                                        errStr := wski18n.T("Unsupported 
runtime type, set to nodejs")
                                        whisk.Debug(whisk.DbgWarn, errStr)
-                                       // TODO() add the user input kind here 
if interactive
+                               // TODO() add the user input kind here if 
interactive
                                }
 
                                wskaction.Exec.Kind = kind
@@ -461,12 +461,12 @@ func (dm *YAMLParser) ComposeActions(filePath string, 
actions map[string]Action,
                                wskaction.Exec.Kind = action.Runtime
 
                        } else if utils.Flags.Strict {
-                               wskaction.Exec.Kind = action.Runtime
-                       } else {
+                               wskaction.Exec.Kind = action.Runtime
+                       } else {
                                errStr := wski18n.T("wskdeploy has chosen a 
particular runtime for the action.\n")
                                whisk.Debug(whisk.DbgWarn, errStr)
                        }
-                }
+               }
 
                // we can specify the name of the action entry point using main
                if action.Main != "" {
diff --git a/parsers/manifest_parser_test.go b/parsers/manifest_parser_test.go
index 558cdeb..3037a6f 100644
--- a/parsers/manifest_parser_test.go
+++ b/parsers/manifest_parser_test.go
@@ -933,11 +933,11 @@ func TestResolveParameterForMultiLineParams(t *testing.T) 
{
     assert.NotNil(t, err, "Expected error saying Invalid type for parameter")
     lines := []string{"Line Unknown"}
     msgs := []string{"Invalid Type for parameter. [invalid]"}
-    expectedErr := utils.NewParserErr("", lines, msgs)
+    expectedErr := utils.NewYAMLParserErr("", lines, msgs)
     switch errorType := err.(type) {
     default:
         assert.Fail(t, "Wrong error type received: We are expecting 
ParserErr.")
-    case *utils.ParserErr:
+    case *utils.YAMLParserErr:
         assert.Equal(t, expectedErr.Message, errorType.Message,
             "Expected error " + expectedErr.Message + " but found " + 
errorType.Message)
     }
diff --git a/parsers/parameters.go b/parsers/parameters.go
index 2c82060..69cb467 100644
--- a/parsers/parameters.go
+++ b/parsers/parameters.go
@@ -95,7 +95,7 @@ func ResolveParamTypeFromValue(name string, value 
interface{}, filePath string)
                        // raise an error if parameter's value is not a known 
type
                        // TODO() - move string to i18n
                        msgs := []string{"Parameter [" + name + "] has a value 
that is not a known type. [" + actualType + "]"}
-                       err = utils.NewParserErr(filePath, nil, msgs)
+                       err = utils.NewYAMLParserErr(filePath, nil, msgs)
                }
        }
        return paramType, err
@@ -127,13 +127,13 @@ func resolveSingleLineParameter(paramName string, param 
*Parameter, filePath str
                                // Type to be that type and its value to that 
Type's default value
                                param.Type = param.Value.(string)
                                param.Value = getTypeDefaultValue(param.Type)
-                               fmt.Printf("EXIT: Parameter [%s] type=[%v] 
value=[%v]\n", paramName, param.Type, param.Value)
+                               //fmt.Printf("EXIT: Parameter [%s] type=[%v] 
value=[%v]\n", paramName, param.Type, param.Value)
                        }
                }
 
        } else {
                msgs := []string{"Parameter [" + paramName + "] is not 
single-line format."}
-               return param.Value, utils.NewParserErr(filePath, nil, msgs)
+               return param.Value, utils.NewYAMLParserErr(filePath, nil, msgs)
        }
 
        return param.Value, errorParser
@@ -166,7 +166,7 @@ func resolveMultiLineParameter(paramName string, param 
*Parameter, filePath stri
                        if !isValidParameterType(param.Type) {
                                // TODO() - move string to i18n
                                msgs := []string{"Parameter [" + paramName + "] 
has an invalid Type. [" + param.Type + "]"}
-                               return param.Value, 
utils.NewParserErr(filePath, nil, msgs)
+                               return param.Value, 
utils.NewYAMLParserErr(filePath, nil, msgs)
                        }
                } else {
                        // if we do not have a value for the Parameter Type, 
use the Parameter Value's Type
@@ -179,7 +179,7 @@ func resolveMultiLineParameter(paramName string, param 
*Parameter, filePath stri
                //}
        } else {
                msgs := []string{"Parameter [" + paramName + "] is not 
multiline format."}
-               return param.Value, utils.NewParserErr(filePath, nil, msgs)
+               return param.Value, utils.NewYAMLParserErr(filePath, nil, msgs)
        }
 
 
@@ -221,7 +221,7 @@ func resolveJSONParameter(paramName string, param 
*Parameter, value interface{},
                } // else TODO{}
        } else {
                msgs := []string{"Parameter [" + paramName + "] is not JSON 
format."}
-               return param.Value, utils.NewParserErr(filePath, nil, msgs)
+               return param.Value, utils.NewYAMLParserErr(filePath, nil, msgs)
        }
 
        return param.Value, errorParser
@@ -296,7 +296,7 @@ type ParsedParameter Parameter
 func (n *Parameter) UnmarshalYAML(unmarshal func(interface{}) error) error {
        var aux ParsedParameter
 
-       // Attempt to unmarshall the multi-line schema
+       // Attempt to unmarshal the multi-line schema
        if err := unmarshal(&aux); err == nil {
                n.multiline = true
                n.Type = aux.Type
diff --git a/tests/src/integration/apigateway/apigateway_test.go 
b/tests/src/integration/apigateway/apigateway_test.go
index 426365f..7723b15 100644
--- a/tests/src/integration/apigateway/apigateway_test.go
+++ b/tests/src/integration/apigateway/apigateway_test.go
@@ -26,8 +26,6 @@ import (
        "os"
 )
 
-var wskprops = common.GetWskprops()
-
 // TODO: write the integration against openwhisk
 func TestTriggerRule(t *testing.T) {
        wskdeploy := common.NewWskdeploy()
diff --git a/tests/src/integration/common/wskdeploy.go 
b/tests/src/integration/common/wskdeploy.go
index 5245d3e..9f6aa5c 100644
--- a/tests/src/integration/common/wskdeploy.go
+++ b/tests/src/integration/common/wskdeploy.go
@@ -121,7 +121,8 @@ func (wskdeploy *Wskdeploy) RunCommand(s ...string) 
(string, error) {
        var returnError error = nil
        if err != nil {
                if len(errb.String()) > 0 {
-                       returnError = utils.NewTestCaseError(errb.String())
+                       // Note: (sub-command) is always at Args[0] which is 
guaranteed to be not empty
+                       returnError = utils.NewCommandError(command.Args[0], 
errb.String())
                } else {
                        returnError = err
                }
diff --git a/utils/wskdeployerror.go b/utils/wskdeployerror.go
index 6613384..54c997e 100644
--- a/utils/wskdeployerror.go
+++ b/utils/wskdeployerror.go
@@ -20,44 +20,44 @@ package utils
 import (
     "fmt"
     "runtime"
-    "github.com/apache/incubator-openwhisk-wskdeploy/wski18n"
     "strings"
     "path/filepath"
 )
 
 const (
-    INVALID_YAML_INPUT = "Invalid input of Yaml file"
-    INVALID_YAML_FORMAT = "Invalid input of Yaml format"
-    OPENWHISK_CLIENT_ERROR = "OpenWhisk Client Error"
-    PARAMETER_TYPE_MISMATCH = "Parameter type mismatch error"
-    MANIFEST_NOT_FOUND = INVALID_YAML_INPUT  // TODO{} This should be a unique 
message.
     UNKNOWN = "Unknown"
     UNKNOWN_VALUE = "Unknown value"
     LINE = "line"
+    PARAMETER = "Parameter"
+    TYPE = "Type"
+    EXPECTED = "expected"
+    ACTUAL = "actual"
+    YAML_FILE = "YAML file"
+
+    ERROR_COMMAND_FAILED = "ERROR_COMMAND_FAILED"
+    ERROR_MANIFEST_FILE_NOT_FOUND = "ERROR_MANIFEST_FILE_NOT_FOUND"
+    ERROR_YAML_FILE_READ_ERROR = "ERROR_YAML_FILE_READ_ERROR"
+    ERROR_YAML_FORMAT_ERROR = "ERROR_YAML_FORMAT_ERROR"
+    ERROR_WHISK_CLIENT_ERROR = "ERROR_WHISK_CLIENT_ERROR"
+    ERROR_WHISK_CLIENT_INVALID_CONFIG = "ERROR_WHISK_CLIENT_INVALID_CONFIG"
+    ERROR_YAML_PARAMETER_TYPE_MISMATCH = "ERROR_YAML_PARAMETER_TYPE_MISMATCH"
 )
 
-type TestCaseError struct {
-    errorMessage string
-}
-
-func NewTestCaseError(errorMessage string) *TestCaseError {
-    return &TestCaseError{
-        errorMessage: errorMessage,
-    }
-}
-
-func (e *TestCaseError) Error() string {
-    return e.errorMessage
-}
-
+/*
+ * BaseError
+ */
 type BaseErr struct {
-    FileName string
-    LineNum  int
-    Message  string
+    ErrorType   string
+    FileName    string
+    LineNum     int
+    Message     string
 }
 
 func (e *BaseErr) Error() string {
-    return fmt.Sprintf("%s [%d]: %s\n", e.FileName, e.LineNum, e.Message)
+    if e.ErrorType == "" {
+        return fmt.Sprintf("%s [%d]: %s\n", e.FileName, e.LineNum, e.Message)
+    }
+    return fmt.Sprintf("%s [%d]: [%s]: %s\n", e.FileName, e.LineNum, 
e.ErrorType, e.Message)
 }
 
 func (e *BaseErr) SetFileName(fileName string) {
@@ -72,167 +72,195 @@ func (e *BaseErr) SetMessage(message string) {
     e.Message = message
 }
 
+func (e *BaseErr) SetErrorType(errorType string) {
+    e.ErrorType = errorType
+}
+
+// func Caller(skip int) (pc uintptr, file string, line int, ok bool)
+func (e *BaseErr) SetCallerByStackFrameSkip(skip int) {
+    _, fn, lineNum, _ := runtime.Caller(skip)
+    e.SetFileName(filepath.Base(fn))
+    e.SetLineNum(lineNum)
+}
+
+/*
+ * CommandError
+ */
+type CommandError struct {
+    BaseErr
+    Command string
+}
+
+func NewCommandError(cmd string, errorMessage string) *CommandError {
+    var err = &CommandError{
+        Command: cmd,
+    }
+    err.SetCallerByStackFrameSkip(2)
+    err.SetErrorType(ERROR_COMMAND_FAILED)
+    err.SetMessage(cmd + ": " + errorMessage)
+    return err
+}
+
+func (e *CommandError) Error() string {
+    return e.BaseErr.Error()
+}
+
+/*
+ * ManifestFileNotFoundError
+ */
 type ErrorManifestFileNotFound struct {
     BaseErr
-    errorType string
+    YAMLFilename string
 }
 
 func NewErrorManifestFileNotFound(errMessage string) 
*ErrorManifestFileNotFound {
-    _, fn, lineNum, _ := runtime.Caller(1)
     var err = &ErrorManifestFileNotFound{
-        errorType: wski18n.T(MANIFEST_NOT_FOUND),
     }
-    //err.SetFileName(fn)
-    err.SetFileName(filepath.Base(fn))
-    err.SetLineNum(lineNum)
+    err.SetErrorType(ERROR_MANIFEST_FILE_NOT_FOUND)
+    err.SetCallerByStackFrameSkip(2)
     err.SetMessage(errMessage)
     return err
 }
 
 func (e *ErrorManifestFileNotFound) Error() string {
-    if e.errorType == "" {
-        return fmt.Sprintf("%s [%d]: %s\n", e.FileName, e.LineNum, e.Message)
-    }
-    return fmt.Sprintf("%s [%d]: %s ==> %s\n", e.FileName, e.LineNum, 
e.errorType, e.Message)
+    return e.BaseErr.Error()
 }
 
-type InputYamlFileError struct {
+/*
+ * YAMLFileReadError
+ */
+type YAMLFileReadError struct {
     BaseErr
-    errorType string
 }
 
-func NewInputYamlFileError(errMessage string) *InputYamlFileError {
-    _, fn, lineNum, _ := runtime.Caller(1)
-    var err = &InputYamlFileError{
-        errorType: wski18n.T(INVALID_YAML_INPUT),
+func NewYAMLFileReadError(errorMessage string) *YAMLFileReadError {
+    var err = &YAMLFileReadError{
+        //errorType: wski18n.T(INVALID_YAML_INPUT),
     }
-    err.SetFileName(filepath.Base(fn))
-    err.SetLineNum(lineNum)
-    err.SetMessage(errMessage)
+    err.SetErrorType(ERROR_YAML_FILE_READ_ERROR)
+    err.SetCallerByStackFrameSkip(2)
+    err.SetMessage(errorMessage)
     return err
 }
 
-func (e *InputYamlFileError) SetErrorType(errorType string) {
-    e.errorType = errorType
-}
-
-func (e *InputYamlFileError) Error() string {
-    if e.errorType == "" {
-        return fmt.Sprintf("%s [%d]: %s\n", e.FileName, e.LineNum, e.Message)
-    }
-    return fmt.Sprintf("%s [%d]: %s %s\n", e.FileName, e.LineNum, e.errorType, 
e.Message)
+func (e *YAMLFileReadError) Error() string {
+    return e.BaseErr.Error()
 }
 
-type InputYamlFormatError struct {
-    InputYamlFileError
+/*
+ * YAMLFormatError
+ */
+type YAMLFormatError struct {
+    YAMLFileReadError
 }
 
-func NewInputYamlFormatError(errMessage string) *InputYamlFormatError {
-    _, fn, lineNum, _ := runtime.Caller(1)
-    var err = &InputYamlFormatError{}
-    err.SetErrorType(wski18n.T(INVALID_YAML_FORMAT))
-    err.SetFileName(fn)
-    err.SetLineNum(lineNum)
-    err.SetMessage(errMessage)
+func NewYAMLFormatError(errorMessage string) *YAMLFormatError {
+    var err = &YAMLFormatError{
+        //err.SetErrorType(wski18n.T(INVALID_YAML_FORMAT))
+    }
+    err.SetErrorType(ERROR_YAML_FORMAT_ERROR)
+    err.SetCallerByStackFrameSkip(2)
+    err.SetMessage(errorMessage)
     return err
 }
 
+/*
+ * WhiskClientError
+ */
 type WhiskClientError struct {
     BaseErr
-    errorType string
-    errorCode int
+    ErrorCode int
 }
 
-func NewWhiskClientError(errMessage string, code int) *WhiskClientError {
-    _, fn, lineNum, _ := runtime.Caller(1)
+func NewWhiskClientError(errorMessage string, code int) *WhiskClientError {
     var err = &WhiskClientError{
-        errorType: wski18n.T(OPENWHISK_CLIENT_ERROR),
-        errorCode: code,
+        //errorType: wski18n.T(OPENWHISK_CLIENT_ERROR),
+        ErrorCode: code,
     }
-    err.SetFileName(fn)
-    err.SetLineNum(lineNum)
-    err.SetMessage(errMessage)
+    err.SetErrorType(ERROR_WHISK_CLIENT_ERROR)
+    err.SetCallerByStackFrameSkip(2)
+    str := fmt.Sprintf("Error Code: %d: %s", code, errorMessage)
+    err.SetMessage(str)
     return err
 }
 
 func (e *WhiskClientError) Error() string {
-    return fmt.Sprintf("%s [%d]: %s =====> %s Error code: %d.\n", e.FileName, 
e.LineNum, e.errorType, e.Message, e.errorCode)
+    return e.BaseErr.Error()
 }
 
-type InvalidWskpropsError struct {
+/*
+ * WhiskClientInvalidConfigError
+ */
+type WhiskClientInvalidConfigError struct {
     BaseErr
 }
 
-func NewInvalidWskpropsError(errMessage string) *InvalidWskpropsError {
-    _, fn, lineNum, _ := runtime.Caller(1)
-    var err = &InvalidWskpropsError{}
-    err.SetFileName(fn)
-    err.SetLineNum(lineNum)
-    err.SetMessage(errMessage)
+func NewWhiskClientInvalidConfigError(errorMessage string) 
*WhiskClientInvalidConfigError {
+    var err = &WhiskClientInvalidConfigError{
+    }
+    err.SetErrorType(ERROR_WHISK_CLIENT_INVALID_CONFIG)
+    err.SetCallerByStackFrameSkip(2)
+    err.SetMessage(errorMessage)
     return err
 }
 
-type ParserErr struct {
+/*
+ * YAMLParserErr
+ */
+type YAMLParserErr struct {
     BaseErr
     YamlFile string
     lines []string
     msgs []string
 }
 
-func NewParserErr(yamlFile string, lines []string, msgs []string) *ParserErr {
-    _, fn, line, _ := runtime.Caller(1)
-    var err = &ParserErr{
+func NewYAMLParserErr(yamlFile string, lines []string, msgs []string) 
*YAMLParserErr {
+    var err = &YAMLParserErr{
         YamlFile: yamlFile,
         lines: lines,
         msgs: msgs,
     }
-    err.SetFileName(fn)
-    err.SetLineNum(line)
+    err.SetCallerByStackFrameSkip(2)
     return err
 }
 
-func (e *ParserErr) Error() string {
+func (e *YAMLParserErr) Error() string {
     result := make([]string, len(e.msgs))
-    var fn = filepath.Base(e.FileName)
 
     for index, msg := range e.msgs {
         var s string
         if e.lines == nil || e.lines[index] == UNKNOWN {
             s = fmt.Sprintf("====> %s", msg)
         } else{
-            s = fmt.Sprintf("====> Line [%v]: %s", e.lines[index], msg)
+            s = fmt.Sprintf("====> %s [%v]: %s", LINE, e.lines[index], msg)
         }
         result[index] = s
     }
-    return fmt.Sprintf("\n==> %s [%d]: Failed to parse the yaml file: %s: 
\n%s", fn, e.LineNum, e.YamlFile, strings.Join(result, "\n"))
+    return fmt.Sprintf("\n==> %s [%d]: %s: %s: \n%s", e.FileName, e.LineNum, 
YAML_FILE, e.YamlFile, strings.Join(result, "\n"))
 }
 
+/*
+ * ParameterTypeMismatchError
+ */
 type ParameterTypeMismatchError struct {
     BaseErr
-    errorType string
-    expectedType string
-    actualType string
+    Parameter       string
+    ExpectedType    string
+    ActualType      string
 }
 
-func (e *ParameterTypeMismatchError) Error() string {
-    if e.errorType == "" {
-        return fmt.Sprintf("%s [%d]: %s\n", e.FileName, e.LineNum, e.Message)
-    }
-    return fmt.Sprintf("%s [%d]: %s ==> %s\n", e.FileName, e.LineNum, 
e.errorType, e.Message)
-}
-
-func NewParameterTypeMismatchError(errMessage string, expectedType string, 
actualType string) *ParameterTypeMismatchError {
-    _, fn, lineNum, _ := runtime.Caller(1)
+func NewParameterTypeMismatchError(param string, expectedType string, 
actualType string) *ParameterTypeMismatchError {
     var err = &ParameterTypeMismatchError{
-        // TODO{} add i18n
-        //errorType: wski18n.T(PARAMETER_TYPE_MISMATCH),
-        errorType: PARAMETER_TYPE_MISMATCH,
-        expectedType: expectedType,
-        actualType: actualType,
+        ExpectedType: expectedType,
+        ActualType: actualType,
     }
-
-    err.SetFileName(filepath.Base(fn))
-    err.SetLineNum(lineNum)
-    err.SetMessage(errMessage)
+    err.SetErrorType(ERROR_YAML_PARAMETER_TYPE_MISMATCH)
+    err.SetCallerByStackFrameSkip(2)
+    str := fmt.Sprintf( "%s [%s]: %s %s: [%s], %s: [%s]", PARAMETER, param, 
TYPE, EXPECTED, expectedType, ACTUAL, actualType)
+    err.SetMessage(str)
     return err
 }
+
+func (e *ParameterTypeMismatchError) Error() string {
+    return e.BaseErr.Error()
+}
diff --git a/wski18n/i18n_resources.go b/wski18n/i18n_resources.go
index 76bb34e..d60b414 100644
--- a/wski18n/i18n_resources.go
+++ b/wski18n/i18n_resources.go
@@ -109,12 +109,12 @@ func wski18nResourcesDe_deAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/de_DE.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1501631495, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/de_DE.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1505354770, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
 
-var _wski18nResourcesEn_usAllJson = 
[]byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\x5d\x6f\xdb\x3a\x12\x7d\xcf\xaf\x18\xe4\xc5\x2f\x81\xb6\xbd\x8b\x05\x16\x7d\x0b\x6e\xbf\x82\xb6\x69\x90\x64\x5b\x14\xdd\x02\x61\xc4\xb1\xc5\x9a\x22\x05\x92\x72\xe0\x1a\xfe\xef\x0b\x8a\x92\xed\x24\x14\x45\xc9\xb2\xb7\xbb\xb8\x79\x72\x64\xce\x39\x67\x86\x5f\x33\x14\xfd\xfd\x04\x60\x75\x02\x00\x70\xca\xe8\xe9\x2b\x38\x7d\x8f\x9c\xcb\xd3\x33\xf7\xc8\x28\x22\x34\x27\x86\x49\x61\xbf\x3b\x17\x70\x7e\x75\x01\x99\xd4\x06\xf2\x52\x1b\xb8\x47\x28\x94\x5c\x30\x8a\x34\x39\x3d\x01\x58\x9f\x3d\x85\xfb\xc4\xb4\x66\x62\x06\x69\x4e\x61\x8e\xcb\x16\xe0\xa6\xd5\x24\xcd\xe9\x04\x98\x28\x4a\x53\xb5\xf6\x42\xe6\x75\xe3\x9c\x08\x36\x45\x6d\x92\x25\xc9\x39\x4c\x19\xc7\x0e\x74\x8f\x81\x97\x80\x94\x26\x93\x8a\xfd\xaa\x00\xe0\xee\xc3\x9b\x6f\x77\x2d\xc8\xbe\x96\x5e\xc8\x87\x8c\xe9\x79\x15\xbc\xbb\xf7\x9f\x6f\x6e\xdb\xf0\x9e\x35\xf3\x82\x09\x92\xa3\x2e\x48\xda\xe6\xef\xf6\xfb\x2e\x2d\x5f\xde\x5c\xdf\x5c\x7c\xbe\x8c\x90\xb3\x69\xe9\xef\xe5\x3a\xb2\x55\x50\x41\x48\x03\x53\x59\x0a\x0a\xc4\x40\x41\x4c\x06\xab\x55\x52\x28\xf9\x13\x53\x73\x45\x4c\xb6\x5e\x27\xff\x16\x6d\x7d\x35\x00\x29\x38\xf0\x56\xab\xaa\xbb\xd7\xeb\xbf\xd9\x4f\xf6\x43\x05\x9d\xc0\x88\x9a\x0f\x41\x15\x11\x67\xa6\x1f\x63\x99\x0c\x1d\xde\xf7\xd5\x2a\xb1\x2d\x1c\xda\x8f\xd8\x68\xf7\xc1\xf3\xca\xfb\x57\x13\x86\x66\xa6\x39\x03\x98\x4a\x05\x14\x0b\x2e\x97\x39\x0a\xd3\x2e\x27\xde\xbe\x37\x7d\x29\xf6\x15\xf0\x14\xc1\x2b\xc1\x86\x4c\x95\xc2\xb0\x7c\x13\x4e\x5d\x16\x85\x54\x06\x29\xdc\x2f\xe1\x73\x81\xc2\xcd\xaa\x82\x13\x33\x95\x2a\x6f\x17\x33\x0c\xcb\x3f\xe5\xf5\xdc\x89\x87\x8c\x68\x48\x33\xa9\x51\x00\x81\x82\x28\xc3\xd2\x92\x13\xb5\x21\xb2\x9e\x5a\x62\x92\x5a\x19\xed\xe2\xf6\x41\xf4\x77\x9e\xd8\x3a\xd7\x98\x9a\x65\x81\x67\xa0\xd1\x80\x91\x20\x24\xc5\x9f\xba\xad\xe3\x22\xad\xbd\xd4\xb7\x56\x5d\x69\x32\x14\x86\xa5\x6e\x29\x9f\xe3\xb2\x89\x79\x2a\xc5\x94\xcd\x4a\x85\xb4\x3d\x1a\x7d\x10\x5a\x25\x6c\xb6\xd6\x9e\xc4\x61\xbb\x56\xba\xcd\x2e\xd1\x97\xaf\xc3\x30\xca\xbf\xd5\x2a\x21\x05\xb3\xff\xad\xd7\x67\x30\x55\x32\xaf\x1f\x69\x59\xaa\x14\x43\xab\xed\x20\xa8\x60\xbf\x37\x7d\xa5\xd1\xec\x00\x94\x26\x8b\x13\x13\x0d\x11\xd7\x15\xab\x55\xb2\xf9\x7f\xd7\xa3\xcd\xc3\x38\x55\xc3\x31\xbd\x32\xdf\x12\xc6\x91\xda\x99\x34\x43\xb7\x33\x3c\x9b\x70\xda\xc1\xda\x65\xe9\x6b\xb5\x2c\x69\x54\x0b\x96\xe2\x2b\xcb\x84\x4a\x85\x14\x8f\x06\xef\x15\x7f\x63\x88\xaa\x56\x81\x52\xe4\x44\xe9\x8c\xf0\x9d\xc5\x93\x89\xa9\x74\xd0\x5c\xa6\x84\xc3\x82\xf0\x12\x75\xbb\xd4\x81\x60\x2d\x8b\x5e\x08\x82\x09\x83\x4a\x60\x68\xbf\x8a\xb6\xf7\xd2\xbf\xde\x6c\x68\x90\xca\xbc\xe0\x68\xc3\xad\xcb\x34\x45\xad\xa7\x25\xe7\xcb\x76\xe6\x28\x53\x2f\xe9\x3b\x69\x00\x95\x92\x0a\x52\x85\xc4\xd8\x0d\xb7\x20\xe9\x9c\xcc\x10\x1e\x98\xc9\xea\xef\x72\xd4\x9a\xcc\x76\x3a\x17\x88\xa0\x8d\x9d\xa4\xee\x0b\xfb\x21\x34\xaa\x0e\x42\x15\xeb\x94\xdb\xef\xfe\x87\x7d\xda\xce\xb4\x3f\x39\xb3\x1d\xfd\xc6\x9a\xb7\xc8\x6a\x69\xec\x05\xbe\x10\x0b\xc2\x19\xad\xeb\x3c\x39\x85\x6f\x1d\x05\x5c\xc0\x20\xba\x37\x0a\x76\x8c\xae\xd8\x8f\x26\xd6\x19\x55\xf2\xa3\x4c\x96\x3d\x79\x3a\xdc\xd1\x68\x2a\x96\x6a\xb5\x37\xc4\x94\xda\x76\xed\x81\x7d\x3b\x08\x69\x6c\xbf\x19\xc5\x66\x33\x54\xc7\xe8\xba\xfd\xa9\xfa\x3a\x35\x45\xa4\xc7\xf4\x6c\x4f\xbe\xbe\x7b\xd3\x3d\x13\xd4\xfe\x7f\xc4\xf5\x7c\x7f\xca\xae\x5d\x5f\x4e\x6d\x5d\x8d\x82\xa2\x48\x97\xd6\x94\x62\x71\x49\x72\x5c\xaf\x81\x32\x5a\x27\xf7\x6e\x77\xb7\x9b\xfb\x66\x6f\x87\xeb\x52\xc0\xdd\xb6\x06\x6c\x6a\xe3\x3b\x9b\x17\x29\xcc\xe5\x02\x5d\x29\x48\x38\x5f\xd6\xa5\x3b\x52\x20\x5a\xa3\x09\xa4\x56\xbf\x83\xb2\x40\xc8\x76\x76\xf5\xd5\x2a\x91\xa5\x29\x4a\xb3\x5e\x43\x92\x24\x41\x7f\x02\x66\x1d\x64\xd5\xb2\xd4\x97\xca\x6b\xd4\x41\xf4\x68\x4e\xf5\x25\x0c\x1a\x77\x10\x37\x43\xbd\x2f\x67\x9b\x5d\x24\x5d\x33\xb3\x86\xd2\xb6\xd9\x77\xd0\x3f\x1e\xd1\xbd\x98\x03\xa6\xfe\xe4\xed\x43\x02\x7f\x12\x91\x22\xe7\xb5\x79\xe7\xe1\x57\xd0\xa4\x83\xc4\x1a\xc4\x1d\xb1\x85\x6d\x5a\xaa\xa4\x6d\xa3\xf0\xec\x0f\x14\x4a\x3d\x20\xba\x56\x4d\xb7\x8c\x0c\xa8\x94\xda\x0c\x7f\x5f\xaf\x1b\x84\xe7\x43\x70\xbb\x1e\xb7\x0f\xdf\x58\xeb\x6e\xff\x87\x6e\x07\x71\xa1\xd9\x03\xbd\x23\x8d\xa0\xc8\xf1\x38\xd5\xe0\x78\x4c\xb1\x2e\x1d\x38\x53\x1f\x8b\xe7\xaf\x2a\xe4\x49\x3c\x0f\x5f\x85\x8c\x48\xd5\xd7\xa9\x03\x57\x21\x63\xf3\xc5\xba\x77\xf8\x13\xb2\x11\xa9\xbc\x4e\x7d\x3d\xbf\xbe\xbc\xb8\x7c\xf7\x0a\x6e\x33\x84\x89\x3b\x6f\x9e\xc0\xb7\xf3\x4f\x1f\xdd\xd9\xb9\xd8\x84\x14\x85\x61\xa6\x3a\x4d\xa7\x58\x28\x4c\x89\x41\x9a\xc0\x15\x47\xa2\x11\x4a\x8d\x30\xb1\x41\x9f\x00\x13\xda\x20\xb1\xb9\x3b\x50\xd4\xa9\x62\xf7\x48\x2d\x8e\x2e\x30\x65\xd3\xfa\x3d\x4c\xa0\xda\xf8\x6f\x2a\x8a\xed\xf7\x26\xd1\x3c\x62\xff\x8f\x47\xd9\x96\x47\xf9\x12\xd9\x8c\x68\xb8\x47\x14\x8f\x72\xa3\x4d\x7d\x16\xcc\xae\x86\xc1\x79\xc5\x5d\x05\xf2\xfb\xa1\x0a\xf7\xc3\x0c\xca\x1c\x53\xde\x08\xb2\x6e\xeb\xe9\x32\x86\xac\x61\x58\x41\x59\xcf\xea\xd3\x7d\xb5\x0d\x00\xf4\x0a\xbc\x7e\x5a\xb1\x0f\x15\x36\x00\xc8\x2b\xe8\xfc\xf9\x69\xc5\x50\x49\x83\xa0\x22\x16\x8e\x6d\x86\xee\x87\x6b\x0a\xcb\xf8\xb5\xa3\x1f\x62\xd7\x04\xa8\xb7\x8e\x5d\xb4\xba\xfa\x8b\x1a\xf3\x61\xf3\xe0\x28\xb2\x59\x64\x2f\xda\x08\xc3\x8e\x51\xe2\x4a\x8e\x5e\xa4\x91\xc6\x1d\xef\xa2\x99\x58\xc8\x39\x56\x69\xb4\x4b\xc4\x32\x14\x47\xca\x09\x8f\x2c\x22\x9c\x53\x7d\x22\x82\x12\x23\xd5\x12\xa6\x0c\x39\x85\x66\x51\xff\x82\x4a\xdb\x30\x37\x97\x35\x75\xe8\x65\xf2\x50\xb4\xb0\xb4\xa7\xc6\xcd\x4d\x26\xb2\x70\xb9\x91\x0d\x5b\x5a\x2a\x65\xeb\xf0\xed\xb1\xed\xc2\xb5\x8e\x10\xbb\x37\xfe\xb0\xc8\x7e\x64\x29\x0a\x8d\x23\x45\xb6\x05\x2d\x2e\xb2\x8d\xf1\xa1\x22\x3b\x18\x3f\x2c\xbf\x81\x5d\xad\x12\xee\x3e\x5e\xbc\x5e\xaf\x1b\x16\x02\xee\x95\xaf\x14\x18\x21\xb5\x17\x96\xff\x52\x31\xe6\x52\x2d\x6f\xd8\x2f\xb4\x95\x38\x67\x39\x33\xda\x3a\xd9\x5c\x04\x04\x9d\xc9\x92\x53\xdb\x39\x44\x54\x37\x2b\xec\xa4\xbe\x47\xf3\x60\x57\xac\x97\x7f\xfc\xb3\x9a\xbe\xff\x78\xf9\x47\xbb\xda\x51\x29\xfc\xb7\x0f\x59\x8e\xd2\xbd\x21\xef\x0d\xff\xe2\x45\x05\xff\xf7\x17\xf6\x2f\x70\x29\x71\x4c\x0a\xaf\x13\x5c\xce\x86\xc6\xc8\xe1\xbf\x0c\xc8\x1f\x09\x3c\x3c\xb2\x9b\xeb\x0a\x15\x83\xbb\x0d\x38\xa9\xe3\x36\xb1\xcc\xf5\x09\xdd\x2e\x33\xd3\xc0\x66\x42\xaa\x9d\xba\x32\xcd\x30\x9d\xbb\x0d\x21\xa6\x88\x3d\x0c\x69\x7f\x47\xb7\xa3\xfc\xb8\xbe\x8e\xc2\xdb\xdf\xdd\x7a\x40\x1d\xd7\xd7\xfd\x49\xbb\x96\xe6\x6a\x6a\xb8\xe5\x34\x67\x46\xb8\xbc\x78\x73\xdf\x33\x23\x62\x46\xee\x39\x02\xd1\xee\x6e\xed\xc3\x19\x3c\x64\x2c\xcd\xe0\x81\x71\x6e\xe7\x4f\xc3\x1f\xb3\x74\x8f\xc8\xe5\x75\xab\xba\xc2\x2e\xa7\xd5\x7e\x95\xcc\x71\x19\xba\x69\xe4\x6f\xdb\x0d\x9b\xa2\x32\xd1\xb8\xdb\xc6\xc1\x1b\xa1\x4d\x7b\x52\x14\xbc\xb9\x55\x5c\xdd\x6c\xad\xea\x14\xf7\x5a\xc9\x6e\x72\x62\xe7\x55\x9d\xbb\xc8\x4f\x4c\x75\x65\x7f\xfb\xf8\x2d\xb3\xa9\xfd\x0f\xa0\x12\x5d\x58\x73\x62\xd2\xac\x42\xef\x66\x6a\x7e\x24\xb0\x76\x64\xf9\xa3\xdf\x0c\xd4\x54\xcd\xc3\x9a\xa8\xed\x85\xd0\xff\x85\x6b\xe1\xb9\xb3\x4b\xe4\xd1\x5f\x0d\x5a\x2d\xa5\xb0\x23\x77\x7b\x9a\x78\x06\xc5\xf6\x34\xb1\xfe\x2d\x48\x73\x9c\x18\x31\x89\x0e\x43\xda\xcb\xd1\xc7\xb1\x3b\x8a\x9b\xa3\x50\x5a\x27\x4f\x4e\x7e\x9c\xfc\x27\x00\x00\xff\xff\x3b\xec\xdb\xc6\x09\x37\x00\x00")
+var _wski18nResourcesEn_usAllJson = 
[]byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\x4d\x6f\xdb\x38\x10\xbd\xe7\x57\x0c\x72\xf1\x25\xd0\xb6\x5d\x2c\xb0\xe8\x2d\xd8\x7e\x05\x6d\x93\x20\xc9\xb6\x28\xba\x05\xc2\x88\x63\x8b\x35\x45\x0a\x24\xe5\xc0\x15\xfc\xdf\x17\x14\x25\xdb\x49\x24\x8a\x92\x65\x6f\x51\x6c\x4f\x8e\xad\x79\xef\xcd\x90\x1c\xce\x50\xec\xd7\x23\x80\xe2\x08\x00\xe0\x98\xd1\xe3\x97\x70\xfc\x0e\x39\x97\xc7\x27\xee\x2b\xa3\x88\xd0\x9c\x18\x26\x85\xfd\xed\x54\xc0\xe9\xe5\x19\x24\x52\x1b\x48\x73\x6d\xe0\x0e\x21\x53\x72\xc1\x28\xd2\xe8\xf8\x08\x60\x75\xf2\x18\xee\x23\xd3\x9a\x89\x19\xc4\x29\x85\x39\x2e\x5b\x80\xeb\xa7\x26\x71\x4a\x27\xc0\x44\x96\x9b\xf2\xe9\x46\x48\x92\x9b\x44\x2a\xf6\xa3\xb4\x86\xdb\xf7\xaf\xbf\xdc\xb6\xc0\x36\x3d\xd9\x08\x79\x9f\x30\x3d\x2f\x7d\xbb\x7d\x77\x71\x7d\xd3\x86\xf7\xe4\xb1\x46\x30\x41\x52\xd4\x19\x89\xb1\x05\x65\xf3\x7b\x97\x96\x4f\xaf\xaf\xae\xcf\x2e\xce\x03\xe4\xac\x9f\x6c\x1e\x04\x22\xd8\x14\xb5\x81\x29\xe3\x08\x42\x1a\x98\xca\x5c\x50\x20\x06\x32\x62\x12\x28\x8a\x28\x53\xf2\x3b\xc6\xe6\x92\x98\x64\xb5\x8a\xfe\x11\x6d\x03\x35\x00\xc9\x3b\x2f\x8a\x22\x5a\x92\x94\xaf\x56\xbf\xd9\x4f\xf6\x43\x09\x1d\xc1\x88\x9a\xf7\x41\x15\x10\x67\xa6\x1f\x62\x99\x04\x1d\xde\xd7\xa2\x88\xec\x13\x0e\xed\x5b\x68\xb4\xfb\xe0\x35\xca\xfb\xbb\x0e\x43\x5a\xe1\x3a\x03\x98\x4a\x05\x14\x33\x2e\x97\x29\x0a\xd3\x2e\x27\xdc\xbe\x37\x7d\x2e\x76\x15\xf0\x18\xa1\x51\x82\x0d\x99\xca\x85\x61\xe9\x3a\x9c\x3a\xcf\x32\xa9\x0c\x52\xb8\x5b\xc2\x45\x86\xc2\xad\xaa\x8c\x13\x33\x95\x2a\x6d\x17\x33\x0c\xab\x79\xc9\xeb\xb9\x13\x0f\x09\xd1\x10\x27\x52\xa3\x00\x02\x19\x51\x86\xc5\x39\x27\x6a\x4d\x64\x3d\xb5\xc4\x24\xb6\x32\xda\xc5\xed\x82\xd8\x3c\x78\x62\xe3\x5c\x6d\x6a\x96\x19\x9e\x80\x46\x03\x46\x82\x90\x14\xbf\xeb\xb6\x81\x0b\xb4\x6e\xa4\xbe\xb1\xea\x72\x93\xa0\x30\x2c\x76\xa9\x7c\x8e\xcb\x3a\xe6\xb1\x14\x53\x36\xcb\x15\xd2\xf6\x68\xf4\x41\x68\x95\xb0\xde\xf9\x7a\x12\xfb\xed\x5a\xe9\xd6\xbb\x44\x5f\xbe\x0e\xc3\x20\xff\x8a\x22\x22\x19\xb3\x7f\xad\x56\x27\x30\x55\x32\xad\xbe\xd2\x32\x57\x31\xfa\xb2\xed\x20\x28\xef\xb8\xd7\x63\xa5\xd1\x6c\x01\xe4\x26\x09\x13\x13\x0c\x11\x36\x14\x45\x11\xad\xff\xde\xf6\x68\xfd\x65\x98\xaa\xe1\x98\x8d\x32\xdf\x10\xc6\x91\xda\x95\x34\x43\xb7\x33\x3c\x59\x70\xda\xc1\xda\xb4\xf4\xb9\x4c\x4b\x1a\xd5\x82\xc5\xf8\xd2\x32\xa1\x52\x3e\xc5\xa3\xc1\x37\x8a\xbf\x36\x44\x95\x59\x20\x17\x29\x51\x3a\x21\x7c\x2b\x79\x32\x31\x95\x0e\x9a\xcb\x98\x70\x58\x10\x9e\xa3\x6e\x97\x3a\x10\xac\x25\xe9\xf9\x20\x98\x30\xa8\x04\xfa\xf6\xab\x60\xfb\x46\xfa\x57\xeb\x0d\x0d\x62\x99\x66\x1c\x6d\xb8\x75\x1e\xc7\xa8\xf5\x34\xe7\x7c\xd9\xce\x1c\x64\xda\x48\xfa\x56\x1a\x40\xa5\xa4\x82\x58\x21\x31\x76\xc3\xcd\x48\x3c\x27\x33\x84\x7b\x66\x92\xea\xb7\x14\xb5\x26\xb3\xad\xc1\x05\x22\x68\x6d\x27\xa9\xfb\xc1\x7e\xf0\xcd\xaa\xbd\x50\x85\x3a\xe5\xf6\xbb\x5f\xcc\xa7\x8c\x1d\xc2\xa1\xdd\x68\x42\x9d\x51\x39\x3f\xc8\x94\xdb\x91\xa7\xc3\x1d\x8d\xa6\x64\x29\x73\xa6\x21\x26\xd7\x20\xa7\xfb\xf6\x6d\x2f\xa4\xa1\xe3\x66\x14\x9b\xcd\x50\x1d\x62\xe8\x76\xa7\xea\xeb\xd4\x14\x91\x1e\xd2\xb3\x1d\xf9\xfa\x66\xf8\x3b\x26\xa8\xfd\xfb\x80\x59\x71\x77\xca\xae\xbd\x53\x4e\x6d\x77\x8a\x82\xa2\x88\x97\xd6\x94\x62\x76\x4e\x52\x5c\xad\x80\x32\x5a\x95\xc8\x6e\x8f\xb4\x5b\xe4\x7a\x87\x84\xab\x5c\xc0\xed\xa6\x93\xaa\x3b\xcc\x5b\x5b\x5d\x28\x4c\xe5\x02\x5d\x43\x45\x38\x5f\x56\x0d\x30\x52\x20\x5a\xa3\xf1\x14\x28\x3f\x83\x32\x4f\xc8\xb6\xf6\xc6\xa2\x88\x64\x6e\xb2\xdc\xac\x56\x10\x45\x91\xd7\x1f\x8f\x59\x07\x59\x99\x96\xfa\x52\x35\x1a\x75\x10\x3d\x58\x53\x7d\x09\xbd\xc6\x1d\xc4\xf5\x54\xef\xcb\xd9\x66\x17\x48\x57\xaf\xac\xa1\xb4\x6d\xf6\x1d\xf4\x0f\x67\x74\x2f\x66\x8f\x69\x23\xe9\xc5\xfb\x08\xfe\x22\x22\x46\xce\x2b\xf3\xce\x23\x24\xaf\x49\x07\x89\x35\x08\x3b\xa8\xf2\xdb\xb4\xf4\x1a\x9b\x87\xfc\xab\xdf\xd3\x6e\xf4\x80\xe8\xca\x9a\x2e\x8d\x0c\xe8\x37\xda\x0c\x7f\x5e\xaf\x6b\x84\xa7\x53\x70\x93\x8f\xdb\xa7\x6f\xa8\x75\xb7\xff\x43\xb7\x83\xb0\xd0\xec\x80\xde\x51\x46\x50\xe4\x78\x98\x9e\x6a\x3c\xa6\x50\x97\xf6\x5c\xa9\x8f\xc5\xf3\x7f\x17\xf2\x28\x9e\xfb\xef\x42\x46\xa4\xea\xeb\xd4\x9e\xbb\x90\xb1\xf9\x42\xdd\xdb\xff\x39\xd3\x88\x54\x8d\x4e\x7d\x3e\xbd\x3a\x3f\x3b\x7f\xfb\x12\x6e\x12\x84\x89\x3b\xb5\x9d\xc0\x97\xd3\x8f\x1f\xdc\x09\xb4\x58\x87\x14\x85\x61\xa6\x3c\x93\xa6\x98\x29\x8c\x89\x41\x1a\xc1\x25\x47\xa2\x11\x72\x8d\x30\xb1\x41\x9f\x00\x13\xda\x20\xb1\xb5\x3b\x50\xd4\xb1\x62\x77\x48\x2d\x8e\xce\x30\x66\xd3\xea\x6d\x86\xa7\xdb\xf8\x2f\x15\x85\x8e\x7b\x5d\x68\x1e\x70\xfc\xc7\xa3\x6c\xab\xa3\x9a\x0a\xd9\x84\x68\xb8\x43\x14\x0f\x6a\xa3\x75\x7f\xe6\xad\xae\x86\xc1\x35\x8a\xbb\xf4\xd4\xf7\x43\x15\xee\x86\xe9\x95\x39\xa6\xbc\x11\x64\xdd\x54\xcb\x65\x0c\x59\xc3\xb0\xbc\xb2\x9e\xf4\xa7\xbb\x6a\x1b\x00\xd8\x28\xf0\xea\x71\xc7\x3e\x54\xd8\x00\xa0\x46\x41\xa7\x4f\x4f\x2b\x86\x4a\x1a\x04\x15\x90\x38\x36\x15\x7a\x33\x5c\xdd\x58\x86\xe7\x8e\x7e\x88\x5d\x0b\xa0\xda\x3a\xb6\xd1\xaa\xee\x2f\x68\xce\xfb\xcd\xbd\xb3\xc8\x56\x91\xbd\x68\x03\x0c\x3b\x66\x89\x6b\x39\x7a\x91\x06\x1a\x77\xbc\xd1\x65\x62\x21\xe7\x58\x96\xd1\xae\x10\x4b\x50\x1c\xa8\x26\x3c\xb0\x08\x7f\x4d\xf5\x91\x08\x4a\x8c\x54\x4b\x98\x32\xe4\x14\xea\xa4\xfe\x09\x95\xb6\x61\xae\x6f\x24\x6a\xdf\x2b\xd9\xa1\x68\x7e\x69\x8f\x8d\xeb\xfb\x40\x64\xe1\x6a\x23\x1b\xb6\x38\x57\xca\xf6\xe1\x9b\x63\xdb\x85\x7b\x3a\x40\xec\xce\xf8\xc3\x22\xfb\x81\xc5\x28\x34\x8e\x14\xd9\x16\xb4\xb0\xc8\xd6\xc6\xfb\x8a\xec\x60\x7c\xbf\xfc\x1a\xb6\x28\x22\xee\x3e\x9e\xbd\x5a\xad\x6a\x16\x02\x0b\xc2\x19\x05\x29\x30\x40\x6a\x2f\xac\x46\x59\x29\xa6\x52\x2d\xaf\xd9\x0f\xb4\x9d\x38\x67\x29\x33\xda\x3a\x59\x5f\xa7\x03\x9d\xc8\x9c\x53\x3b\x38\x44\x94\xf7\x13\xec\xa2\xbe\x43\x73\x6f\x33\xd6\xf3\x17\x7f\x96\xcb\xf7\x8f\xe7\x2f\xda\xd5\x8e\x4a\xd1\x7c\x87\x8f\xa5\x28\x73\x33\x08\xfe\xd9\xb3\x12\xfe\xf7\x67\xf6\x9f\xe7\x6a\xdf\x98\x14\x8d\x4e\x70\x39\x1b\x1a\x23\x87\xff\xdc\x23\x7f\x24\x70\xff\xcc\x3e\x13\x6e\xbe\x95\x0c\xee\x4e\xdd\xa4\x8a\xdb\xc4\x32\x57\x27\x74\xdb\xcc\x4c\x03\x9b\x09\xa9\xb6\xfa\xca\x38\xc1\x78\xee\x36\x84\x90\x26\x76\x3f\xa4\xfd\x1d\xdd\xcc\xf2\xc3\xfa\x3a\x0a\x6f\x7f\x77\xab\x09\x75\x58\x5f\x77\x27\xed\x4a\xcd\xe5\xd2\x70\xe9\x34\x65\x46\xb8\xba\x78\x7d\x6b\x32\x21\x62\x46\xee\x38\x02\xd1\xee\x86\xea\xfd\x09\xdc\x27\x2c\x4e\xe0\x9e\x71\x6e\xd7\x4f\xcd\x1f\x92\xba\x47\xe4\x6a\x74\xab\xbc\x08\x2e\xa7\xe5\x7e\x15\xcd\x71\x59\x5e\x19\x6f\x91\xd5\xfc\x6c\x37\x6c\x8c\xca\x04\xe3\x6e\x1e\xf6\xde\xab\xac\x9f\x27\x59\xc6\xeb\xbb\xb9\xe5\xfd\xd0\xb2\x4f\x71\xaf\x95\xec\x26\x27\xb6\x5e\xd5\xb9\xeb\xf0\xc4\x94\x17\xdf\x37\x5f\xbf\x61\xb6\xb4\xff\x06\x54\xa2\x0b\x6b\x4a\x4c\x9c\x94\xe8\xdd\x4c\xf5\x55\xfb\x95\x23\x4b\x1f\xdc\xbc\xaf\xa8\xea\x2f\x2b\xa2\xb6\x17\x42\xbf\x84\x6b\xfe\xb5\xb3\x4d\xd4\xa0\xbf\x9c\xb4\x5a\x4a\x61\x67\xee\xe6\x34\xf1\x04\xb2\xcd\x69\x62\xf5\x3f\x2a\xea\xe3\xc4\x80\x45\xb4\x1f\xd2\x5e\x8e\x3e\x8c\xdd\x41\xdc\x1c\x85\xd2\x3a\x79\x74\xf4\xed\xe8\xdf\x00\x00\x00\xff\xff\xd4\x73\xd6\x86\xee\x35\x00\x00")
 
 func wski18nResourcesEn_usAllJsonBytes() ([]byte, error) {
        return bindataRead(
@@ -129,7 +129,7 @@ func wski18nResourcesEn_usAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/en_US.all.json", size: 
14089, mode: os.FileMode(420), modTime: time.Unix(1508886382, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/en_US.all.json", size: 
13806, mode: os.FileMode(420), modTime: time.Unix(1509045117, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
@@ -149,7 +149,7 @@ func wski18nResourcesEs_esAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/es_ES.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1501631495, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/es_ES.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1505354770, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
@@ -169,7 +169,7 @@ func wski18nResourcesFr_frAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/fr_FR.all.json", size: 
101, mode: os.FileMode(420), modTime: time.Unix(1501631495, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/fr_FR.all.json", size: 
101, mode: os.FileMode(420), modTime: time.Unix(1505354770, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
@@ -189,7 +189,7 @@ func wski18nResourcesIt_itAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/it_IT.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1501631495, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/it_IT.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1505354770, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
@@ -209,7 +209,7 @@ func wski18nResourcesJa_jaAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/ja_JA.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1501631495, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/ja_JA.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1505354770, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
@@ -229,7 +229,7 @@ func wski18nResourcesKo_krAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/ko_KR.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1501631495, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/ko_KR.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1505354770, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
@@ -249,7 +249,7 @@ func wski18nResourcesPt_brAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/pt_BR.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1501631495, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/pt_BR.all.json", size: 
0, mode: os.FileMode(420), modTime: time.Unix(1505354770, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
@@ -269,7 +269,7 @@ func wski18nResourcesZh_hansAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/zh_Hans.all.json", 
size: 0, mode: os.FileMode(420), modTime: time.Unix(1501631495, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/zh_Hans.all.json", 
size: 0, mode: os.FileMode(420), modTime: time.Unix(1505354770, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
@@ -289,7 +289,7 @@ func wski18nResourcesZh_hantAllJson() (*asset, error) {
                return nil, err
        }
 
-       info := bindataFileInfo{name: "wski18n/resources/zh_Hant.all.json", 
size: 0, mode: os.FileMode(420), modTime: time.Unix(1501631495, 0)}
+       info := bindataFileInfo{name: "wski18n/resources/zh_Hant.all.json", 
size: 0, mode: os.FileMode(420), modTime: time.Unix(1505354770, 0)}
        a := &asset{bytes: bytes, info: info}
        return a, nil
 }
diff --git a/wski18n/resources/en_US.all.json b/wski18n/resources/en_US.all.json
index 8cfb67c..d23dfab 100644
--- a/wski18n/resources/en_US.all.json
+++ b/wski18n/resources/en_US.all.json
@@ -8,10 +8,6 @@
     "translation": "Missing 'cmd' input key"
   },
   {
-    "id": "missing manifest.yaml file",
-    "translation": "Missing manifest.yaml file"
-  },
-  {
     "id": "authorization `KEY`",
     "translation": "authorization `KEY`"
   },
@@ -108,14 +104,6 @@
     "translation": "Got error creating package with error message: {{.err}} 
and error code: {{.code}}.\n"
   },
   {
-    "id": "OpenWhisk Client Error",
-    "translation": "OpenWhisk Client Error"
-  },
-  {
-    "id": "Invalid input of Yaml file",
-    "translation": "Invalid input of Yaml file"
-  },
-  {
     "id": "Got error creating api with error message: {{.err}} and error code: 
{{.code}}.\n",
     "translation": "Got error creating api with error message: {{.err}} and 
error code: {{.code}}.\n"
   },


 

----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
 
For queries about this service, please contact Infrastructure at:
[email protected]


With regards,
Apache Git Services

Reply via email to