You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openwhisk.apache.org by ho...@apache.org on 2017/12/01 19:50:51 UTC

[incubator-openwhisk-wskdeploy] branch master updated: Refactor "error" related data/functions into their own pkg to avoid cycles. (#665)

This is an automated email from the ASF dual-hosted git repository.

houshengbo pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-openwhisk-wskdeploy.git


The following commit(s) were added to refs/heads/master by this push:
     new 6dfb9e7  Refactor "error" related data/functions into their own pkg to avoid cycles. (#665)
6dfb9e7 is described below

commit 6dfb9e7f90c531250e88d620e4145b8c4d77f145
Author: Matt Rutkowski <mr...@us.ibm.com>
AuthorDate: Fri Dec 1 13:50:49 2017 -0600

    Refactor "error" related data/functions into their own pkg to avoid cycles. (#665)
    
    * Refactor error code into its own pkg to avoid cycles.
    
    * Refactor error code into its own pkg to avoid cycles.
    
    * Refactor error code into its own pkg to avoid cycles.
    
    * Simplify command error usage logic.
---
 cmd/root.go                                  |  9 ++---
 deployers/deploymentreader.go                |  7 ++--
 deployers/filesystemreader.go                |  7 ++--
 deployers/manifestreader.go                  | 45 ++++++++++++------------
 deployers/servicedeployer.go                 | 51 ++++++++++++++--------------
 deployers/whiskclient.go                     | 12 ++++---
 parsers/deploy_parser.go                     |  5 +--
 parsers/manifest_parser.go                   | 11 +++---
 parsers/manifest_parser_test.go              |  4 +--
 parsers/parameters.go                        | 13 +++----
 tests/src/integration/common/wskdeploy.go    |  9 ++---
 {utils => wskderrors}/wskdeployerror.go      |  2 +-
 {utils => wskderrors}/wskdeployerror_test.go |  3 +-
 13 files changed, 92 insertions(+), 86 deletions(-)

diff --git a/cmd/root.go b/cmd/root.go
index df579cf..d07005f 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -31,6 +31,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 var stderr = ""
@@ -180,7 +181,7 @@ func Deploy() error {
 			errString := wski18n.T("Missing {{.yaml}}/{{.yml}} file. Manifest file not found at path {{.projectPath}}.\n",
 				map[string]interface{}{"yaml": utils.ManifestFileNameYaml, "yml": utils.ManifestFileNameYml,
 					"projectPath": projectPath})
-			return utils.NewErrorManifestFileNotFound(projectPath, errString)
+			return wskderrors.NewErrorManifestFileNotFound(projectPath, errString)
 		}
 		whisk.Debug(whisk.DbgInfo, stdout)
 	}
@@ -239,7 +240,7 @@ func Deploy() error {
 		errString := wski18n.T("Manifest file is not found at the path [{{.filePath}}].\n",
 			map[string]interface{}{"filePath": utils.Flags.ManifestPath})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewErrorManifestFileNotFound(utils.Flags.ManifestPath, errString)
+		return wskderrors.NewErrorManifestFileNotFound(utils.Flags.ManifestPath, errString)
 	}
 
 }
@@ -273,7 +274,7 @@ func Undeploy() error {
 			errString := wski18n.T("Missing {{.yaml}}/{{.yml}} file. Manifest file not found at path {{.projectPath}}.\n",
 				map[string]interface{}{"yaml": utils.ManifestFileNameYaml, "yml": utils.ManifestFileNameYml,
 					"projectPath": projectPath})
-			return utils.NewErrorManifestFileNotFound(projectPath, errString)
+			return wskderrors.NewErrorManifestFileNotFound(projectPath, errString)
 		}
 		whisk.Debug(whisk.DbgInfo, stdout)
 	}
@@ -330,6 +331,6 @@ func Undeploy() error {
 		errString := wski18n.T("Manifest file is not found at the path [{{.filePath}}].\n",
 			map[string]interface{}{"filePath": utils.Flags.ManifestPath})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewErrorManifestFileNotFound(utils.Flags.ManifestPath, errString)
+		return wskderrors.NewErrorManifestFileNotFound(utils.Flags.ManifestPath, errString)
 	}
 }
diff --git a/deployers/deploymentreader.go b/deployers/deploymentreader.go
index 39dbd76..c788b51 100644
--- a/deployers/deploymentreader.go
+++ b/deployers/deploymentreader.go
@@ -23,6 +23,7 @@ import (
 	"github.com/apache/incubator-openwhisk-wskdeploy/parsers"
 	"github.com/apache/incubator-openwhisk-wskdeploy/utils"
 	"github.com/apache/incubator-openwhisk-wskdeploy/wski18n"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 type DeploymentReader struct {
@@ -148,7 +149,7 @@ func (reader *DeploymentReader) bindPackageInputsAndAnnotations() error {
 					// TODO() i18n, need to use an ID
 					// TODO() fix grammar error; need command before "but"
 					err := errors.New(wski18n.T("Annotation key \"" + name + "\" does not exist in manifest file but specified in deployment file."))
-					return utils.NewYAMLFileFormatError(reader.DeploymentDescriptor.Filepath, err)
+					return wskderrors.NewYAMLFileFormatError(reader.DeploymentDescriptor.Filepath, err)
 				}
 			}
 		}
@@ -238,7 +239,7 @@ func (reader *DeploymentReader) bindActionInputsAndAnnotations() error {
 					if !keyExistsInManifest {
 						// TODO() i18n, need to use an ID
 						err := errors.New(wski18n.T("Annotation key \"" + name + "\" does not exist in manifest file but specified in deployment file."))
-						return utils.NewYAMLFileFormatError(reader.DeploymentDescriptor.Filepath, err)
+						return wskderrors.NewYAMLFileFormatError(reader.DeploymentDescriptor.Filepath, err)
 					}
 				}
 			}
@@ -325,7 +326,7 @@ func (reader *DeploymentReader) bindTriggerInputsAndAnnotations() error {
 					if !keyExistsInManifest {
 						// TODO() i18n, need to use an ID
 						err := errors.New(wski18n.T("Annotation key \"" + name + "\" does not exist in manifest file but specified in deployment file."))
-						return utils.NewYAMLFileFormatError(reader.DeploymentDescriptor.Filepath, err)
+						return wskderrors.NewYAMLFileFormatError(reader.DeploymentDescriptor.Filepath, err)
 					}
 				}
 			}
diff --git a/deployers/filesystemreader.go b/deployers/filesystemreader.go
index f99a379..3bacf0d 100644
--- a/deployers/filesystemreader.go
+++ b/deployers/filesystemreader.go
@@ -26,6 +26,7 @@ import (
 	"github.com/apache/incubator-openwhisk-client-go/whisk"
 	"github.com/apache/incubator-openwhisk-wskdeploy/parsers"
 	"github.com/apache/incubator-openwhisk-wskdeploy/utils"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 // name of directory that can contain source code
@@ -56,7 +57,7 @@ func (reader *FileSystemReader) ReadProjectDirectory(manifest *parsers.YAML) ([]
 		if fpath != reader.serviceDeployer.ProjectPath {
 			pathCount, err := reader.getFilePathCount(fpath)
             if err != nil {
-                return utils.NewFileReadError(fpath, err.Error())
+                return wskderrors.NewFileReadError(fpath, err.Error())
             }
 
 			if !f.IsDir() {
@@ -76,7 +77,7 @@ func (reader *FileSystemReader) ReadProjectDirectory(manifest *parsers.YAML) ([]
 					if foundFile == true {
 						_, action, err := reader.CreateActionFromFile(reader.serviceDeployer.ManifestPath, fpath)
                         if err != nil {
-                            return utils.NewFileReadError(fpath, err.Error())
+                            return wskderrors.NewFileReadError(fpath, err.Error())
                         }
 
 						var record utils.ActionRecord
@@ -127,7 +128,7 @@ func (reader *FileSystemReader) CreateActionFromFile(manipath, filePath string)
 
 		dat, err := new(utils.ContentReader).LocalReader.ReadLocal(filePath)
         if err != nil {
-            return name, action, utils.NewFileReadError(filePath, err.Error())
+            return name, action, wskderrors.NewFileReadError(filePath, err.Error())
         }
 
 		action.Exec = new(whisk.Exec)
diff --git a/deployers/manifestreader.go b/deployers/manifestreader.go
index 85ece58..a8df385 100644
--- a/deployers/manifestreader.go
+++ b/deployers/manifestreader.go
@@ -24,6 +24,7 @@ import (
 	"github.com/apache/incubator-openwhisk-client-go/whisk"
 	"github.com/apache/incubator-openwhisk-wskdeploy/parsers"
 	"github.com/apache/incubator-openwhisk-wskdeploy/utils"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 var clientConfig *whisk.Config
@@ -69,62 +70,62 @@ func (deployer *ManifestReader) HandleYaml(sdeployer *ServiceDeployer, manifestP
 
 	deps, err := manifestParser.ComposeDependenciesFromAllPackages(manifest, deployer.serviceDeployer.ProjectPath, deployer.serviceDeployer.ManifestPath)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	actions, err := manifestParser.ComposeActionsFromAllPackages(manifest, deployer.serviceDeployer.ManifestPath, ma)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	sequences, err := manifestParser.ComposeSequencesFromAllPackages(deployer.serviceDeployer.ClientConfig.Namespace, manifest, ma)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	triggers, err := manifestParser.ComposeTriggersFromAllPackages(manifest, deployer.serviceDeployer.ManifestPath, ma)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	rules, err := manifestParser.ComposeRulesFromAllPackages(manifest)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	apis, err := manifestParser.ComposeApiRecordsFromAllPackages(manifest)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	err = deployer.SetDependencies(deps)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	err = deployer.SetActions(actions)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	err = deployer.SetSequences(sequences)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	err = deployer.SetTriggers(triggers)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	err = deployer.SetRules(rules)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	err = deployer.SetApis(apis)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(manifestName, err)
+		return wskderrors.NewYAMLFileFormatError(manifestName, err)
 	}
 
 	return nil
@@ -143,7 +144,7 @@ func (reader *ManifestReader) SetDependencies(deps map[string]utils.DependencyRe
 				gitReader := utils.NewGitReader(depName, dep)
 				err := gitReader.CloneDependency()
 				if err != nil {
-					return utils.NewYAMLFileFormatError(depName, err)
+					return wskderrors.NewYAMLFileFormatError(depName, err)
 				}
 			} else {
 				// TODO: we should do a check to make sure this dependency is compatible with an already installed one.
@@ -184,7 +185,7 @@ func (reader *ManifestReader) SetPackage(packages map[string]*whisk.Package) err
 				// TODO(): i18n of error message (or create a new named error)
 				// TODO(): Is there a better way to handle an existing dependency of same name?
 				err := errors.New("Package [" + pkg.Name + "] exists already.")
-				return utils.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
+				return wskderrors.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
 			}
 		}
 		newPack := NewDeploymentPackage()
@@ -229,7 +230,7 @@ func (reader *ManifestReader) SetActions(actions []utils.ActionRecord) error {
 
 				err := reader.checkAction(existAction)
 				if err != nil {
-					return utils.NewFileReadError(manifestAction.Filepath, err)
+					return wskderrors.NewFileReadError(manifestAction.Filepath, err)
 				}
 
 			} else {
@@ -238,13 +239,13 @@ func (reader *ManifestReader) SetActions(actions []utils.ActionRecord) error {
 				err := errors.New("Conflict detected for action named [" +
 					existAction.Action.Name + "].\nFound two locations for source file: [" +
 					existAction.Filepath + "] and [" + manifestAction.Filepath + "]")
-				return utils.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
+				return wskderrors.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
 			}
 		} else {
 			// not a new action so update the action in the package
 			err := reader.checkAction(manifestAction)
 			if err != nil {
-				return utils.NewFileReadError(manifestAction.Filepath, err)
+				return wskderrors.NewFileReadError(manifestAction.Filepath, err)
 			}
 			reader.serviceDeployer.Deployment.Packages[manifestAction.Packagename].Actions[manifestAction.Action.Name] = manifestAction
 		}
@@ -258,13 +259,13 @@ func (reader *ManifestReader) checkAction(action utils.ActionRecord) error {
 	if action.Filepath == "" {
 		// TODO(): i18n of error message (or create a new named error)
 		err := errors.New("Action [" + action.Action.Name + "] has no source code location set.")
-		return utils.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
+		return wskderrors.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
 	}
 
 	if action.Action.Exec.Kind == "" {
 		// TODO(): i18n of error message (or create a new named error)
 		err := errors.New("Action [" + action.Action.Name + "] has no kind set.")
-		return utils.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
+		return wskderrors.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
 	}
 
 	if action.Action.Exec.Code != nil {
@@ -272,7 +273,7 @@ func (reader *ManifestReader) checkAction(action utils.ActionRecord) error {
 		if code == "" && action.Action.Exec.Kind != "sequence" {
 			// TODO(): i18n of error message (or create a new named error)
 			err := errors.New("Action [" + action.Action.Name + "] has no source code.")
-			return utils.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
+			return wskderrors.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
 		}
 	}
 
@@ -293,7 +294,7 @@ func (reader *ManifestReader) SetSequences(actions []utils.ActionRecord) error {
 			// TODO(): i18n of error message (or create a new named error)
 			err := errors.New("Sequence action's name [" +
 				seqAction.Action.Name + "] is already used by an action.")
-			return utils.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
+			return wskderrors.NewYAMLParserErr(reader.serviceDeployer.ManifestPath, err)
 		}
 		existAction, exists := reader.serviceDeployer.Deployment.Packages[seqAction.Packagename].Sequences[seqAction.Action.Name]
 
@@ -311,7 +312,7 @@ func (reader *ManifestReader) SetSequences(actions []utils.ActionRecord) error {
 			err := reader.checkAction(seqAction)
 			if err != nil {
 				// TODO() Need a better error type here
-				return utils.NewFileReadError(seqAction.Filepath, err)
+				return wskderrors.NewFileReadError(seqAction.Filepath, err)
 			}
 			reader.serviceDeployer.Deployment.Packages[seqAction.Packagename].Sequences[seqAction.Action.Name] = seqAction
 		}
diff --git a/deployers/servicedeployer.go b/deployers/servicedeployer.go
index 275ecde..183798a 100644
--- a/deployers/servicedeployer.go
+++ b/deployers/servicedeployer.go
@@ -25,13 +25,14 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"reflect"
+	"time"
 
 	"github.com/apache/incubator-openwhisk-client-go/whisk"
 	"github.com/apache/incubator-openwhisk-wskdeploy/parsers"
 	"github.com/apache/incubator-openwhisk-wskdeploy/utils"
 	"github.com/apache/incubator-openwhisk-wskdeploy/wski18n"
-	"reflect"
-    "time"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 const (
@@ -141,14 +142,14 @@ func (deployer *ServiceDeployer) ConstructDeploymentPlan() error {
 		// Project Name in manifest/deployment file is mandatory for managed deployments
 		if deployer.ProjectName == "" {
 			// TODO see if we can move string to translation file.
-			return utils.NewYAMLFileFormatError(manifest.Filepath, "Project name in manifest file is mandatory for managed deployments")
+			return wskderrors.NewYAMLFileFormatError(manifest.Filepath, "Project name in manifest file is mandatory for managed deployments")
 		}
 		// Every OpenWhisk entity in the manifest file will be annotated with:
 		//managed: '{"__OW__PROJECT__NAME": <name>, "__OW__PROJECT_HASH": <hash>, "__OW__FILE": <path>}'
 		deployer.ManagedAnnotation, err = utils.GenerateManagedAnnotation(deployer.ProjectName, manifest.Filepath)
 		if err != nil {
 			// TODO see if we can pass in the YAML file path on first parameter
-			return utils.NewYAMLFileFormatError(manifest.Filepath, err.Error())
+			return wskderrors.NewYAMLFileFormatError(manifest.Filepath, err.Error())
 		}
 	}
 
@@ -202,7 +203,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.NewYAMLFileFormatError(manifest.Filepath, errorString)
+				return wskderrors.NewYAMLFileFormatError(manifest.Filepath, errorString)
 			}
 		}
 		if err := deploymentReader.BindAssets(); err != nil {
@@ -278,7 +279,7 @@ 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.NewYAMLFileFormatError(manifest.Filepath, errorString)
+				return deployer.Deployment, wskderrors.NewYAMLFileFormatError(manifest.Filepath, errorString)
 			}
 		}
 
@@ -707,7 +708,7 @@ func (deployer *ServiceDeployer) createBinding(packa *whisk.BindingPackage) erro
 		errString := wski18n.T("Got error creating package binding with error message: {{.err}} and error code: {{.code}}.\n",
 			map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+		return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 	} else {
 		output := wski18n.T("Package binding {{.output}} has been successfully deployed.\n",
 			map[string]interface{}{"output": packa.Name})
@@ -730,7 +731,7 @@ func (deployer *ServiceDeployer) createPackage(packa *whisk.Package) error {
 		errString := wski18n.T("Got error creating package with error message: {{.err}} and error code: {{.code}}.\n",
 			map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+		return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 	} else {
 		output := wski18n.T("Package {{.output}} has been successfully deployed.\n",
 			map[string]interface{}{"output": packa.Name})
@@ -753,7 +754,7 @@ func (deployer *ServiceDeployer) createTrigger(trigger *whisk.Trigger) error {
 		errString := wski18n.T("Got error creating trigger with error message: {{.err}} and error code: {{.code}}.\n",
 			map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+		return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 	} else {
 		output := wski18n.T("Trigger {{.output}} has been successfully deployed.\n",
 			map[string]interface{}{"output": trigger.Name})
@@ -807,7 +808,7 @@ func (deployer *ServiceDeployer) createFeedAction(trigger *whisk.Trigger, feedNa
 		errString := wski18n.T("Got error creating trigger with error message: {{.err}} and error code: {{.code}}.\n",
 			map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+		return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 	} else {
 
 		qName, err := utils.ParseQualifiedName(feedName, deployer.ClientConfig.Namespace)
@@ -836,7 +837,7 @@ func (deployer *ServiceDeployer) createFeedAction(trigger *whisk.Trigger, feedNa
 			errString := wski18n.T("Got error creating trigger feed with error message: {{.err}} and error code: {{.code}}.\n",
 				map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 			whisk.Debug(whisk.DbgError, errString)
-			return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+			return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 		}
 	}
 	output = wski18n.T("Trigger feed {{.output}} has been successfully deployed.\n",
@@ -874,7 +875,7 @@ func (deployer *ServiceDeployer) createRule(rule *whisk.Rule) error {
 		errString := wski18n.T("Got error creating rule with error message: {{.err}} and error code: {{.code}}.\n",
 			map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+		return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 	}
 
 	output = wski18n.T("Rule {{.output}} has been successfully deployed.\n",
@@ -905,7 +906,7 @@ func (deployer *ServiceDeployer) createAction(pkgname string, action *whisk.Acti
 		errString := wski18n.T("Got error creating action with error message: {{.err}} and error code: {{.code}}.\n",
 			map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+		return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 	} else {
 		output := wski18n.T("Action {{.output}} has been successfully deployed.\n",
 			map[string]interface{}{"output": action.Name})
@@ -927,7 +928,7 @@ func (deployer *ServiceDeployer) createApi(api *whisk.ApiCreateRequest) error {
 		errString := wski18n.T("Got error creating api with error message: {{.err}} and error code: {{.code}}.\n",
 			map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+		return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 	}
 	return nil
 }
@@ -1047,7 +1048,7 @@ func (deployer *ServiceDeployer) UnDeployDependencies() error {
 							errString := wski18n.T("Got error deleting binding package with error message: {{.err}} and error code: {{.code}}.\n",
 								map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 							whisk.Debug(whisk.DbgError, errString)
-							return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+							return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 						}
 					}
 				}
@@ -1154,7 +1155,7 @@ func (deployer *ServiceDeployer) deletePackage(packa *whisk.Package) error {
 			errString := wski18n.T("Got error deleting package with error message: {{.err}} and error code: {{.code}}.\n",
 				map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 			whisk.Debug(whisk.DbgError, errString)
-			return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+			return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 		}
 	}
 	return nil
@@ -1176,7 +1177,7 @@ func (deployer *ServiceDeployer) deleteTrigger(trigger *whisk.Trigger) error {
 		errString := wski18n.T("Got error deleting trigger with error message: {{.err}} and error code: {{.code}}.\n",
 			map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+		return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 	} else {
 		output := wski18n.T("Trigger {{.trigger}} has been removed.\n",
 			map[string]interface{}{"trigger": trigger.Name})
@@ -1216,7 +1217,7 @@ func (deployer *ServiceDeployer) deleteFeedAction(trigger *whisk.Trigger, feedNa
 		errString := wski18n.T("Failed to invoke the feed when deleting trigger feed with error message: {{.err}} and error code: {{.code}}.\n",
 			map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 		whisk.Debug(whisk.DbgError, errString)
-		return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+		return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 
 	} else {
 		trigger.Parameters = nil
@@ -1231,7 +1232,7 @@ func (deployer *ServiceDeployer) deleteFeedAction(trigger *whisk.Trigger, feedNa
 			errString := wski18n.T("Got error deleting trigger with error message: {{.err}} and error code: {{.code}}.\n",
 				map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 			whisk.Debug(whisk.DbgError, errString)
-			return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+			return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 		}
 	}
 
@@ -1254,7 +1255,7 @@ func (deployer *ServiceDeployer) deleteRule(rule *whisk.Rule) error {
         errString := wski18n.T("Got error deleting rule with error message: {{.err}} and error code: {{.code}}.\n",
             map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
         whisk.Debug(whisk.DbgError, errString)
-        return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+        return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
     }
 	output = wski18n.T("Rule {{.rule}} has been removed.\n",
 		map[string]interface{}{"rule": rule.Name})
@@ -1286,7 +1287,7 @@ func (deployer *ServiceDeployer) deleteAction(pkgname string, action *whisk.Acti
 			errString := wski18n.T("Got error deleting action with error message: {{.err}} and error code: {{.code}}.\n",
 				map[string]interface{}{"err": wskErr.Error(), "code": strconv.Itoa(wskErr.ExitCode)})
 			whisk.Debug(whisk.DbgError, errString)
-			return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+			return wskderrors.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
 
 		}
 		output = wski18n.T("Action {{.action}} has been removed.\n",
@@ -1344,7 +1345,7 @@ func (deployer *ServiceDeployer) printDeploymentAssets(assets *DeploymentProject
 		for _, p := range pack.Package.Parameters {
 			jsonValue, err := utils.PrettyJSON(p.Value)
 			if err != nil {
-				fmt.Printf("        - %s : %s\n", p.Key, utils.STR_UNKNOWN_VALUE)
+				fmt.Printf("        - %s : %s\n", p.Key, wskderrors.STR_UNKNOWN_VALUE)
 			} else {
 				fmt.Printf("        - %s : %v\n", p.Key, jsonValue)
 			}
@@ -1372,7 +1373,7 @@ func (deployer *ServiceDeployer) printDeploymentAssets(assets *DeploymentProject
 					} else {
 						jsonValue, err := utils.PrettyJSON(p.Value)
 						if err != nil {
-							fmt.Printf("        - %s : %s\n", p.Key, utils.STR_UNKNOWN_VALUE)
+							fmt.Printf("        - %s : %s\n", p.Key, wskderrors.STR_UNKNOWN_VALUE)
 						} else {
 							fmt.Printf("        - %s : %v\n", p.Key, jsonValue)
 						}
@@ -1380,7 +1381,7 @@ func (deployer *ServiceDeployer) printDeploymentAssets(assets *DeploymentProject
 				} else {
 					jsonValue, err := utils.PrettyJSON(p.Value)
 					if err != nil {
-						fmt.Printf("        - %s : %s\n", p.Key, utils.STR_UNKNOWN_VALUE)
+						fmt.Printf("        - %s : %s\n", p.Key, wskderrors.STR_UNKNOWN_VALUE)
 					} else {
 						fmt.Printf("        - %s : %v\n", p.Key, jsonValue)
 					}
@@ -1410,7 +1411,7 @@ func (deployer *ServiceDeployer) printDeploymentAssets(assets *DeploymentProject
 		for _, p := range trigger.Parameters {
 			jsonValue, err := utils.PrettyJSON(p.Value)
 			if err != nil {
-				fmt.Printf("        - %s : %s\n", p.Key, utils.STR_UNKNOWN_VALUE)
+				fmt.Printf("        - %s : %s\n", p.Key, wskderrors.STR_UNKNOWN_VALUE)
 			} else {
 				fmt.Printf("        - %s : %v\n", p.Key, jsonValue)
 			}
diff --git a/deployers/whiskclient.go b/deployers/whiskclient.go
index 92d66fc..a5fb5ad 100644
--- a/deployers/whiskclient.go
+++ b/deployers/whiskclient.go
@@ -20,15 +20,17 @@ package deployers
 import (
 	"bufio"
 	"fmt"
-	"github.com/apache/incubator-openwhisk-client-go/whisk"
-	"github.com/apache/incubator-openwhisk-wskdeploy/parsers"
-	"github.com/apache/incubator-openwhisk-wskdeploy/utils"
-	"github.com/apache/incubator-openwhisk-wskdeploy/wski18n"
 	"net/http"
 	"os"
 	"path"
 	"strings"
 	"time"
+
+	"github.com/apache/incubator-openwhisk-client-go/whisk"
+	"github.com/apache/incubator-openwhisk-wskdeploy/parsers"
+	"github.com/apache/incubator-openwhisk-wskdeploy/utils"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wski18n"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 const (
@@ -234,7 +236,7 @@ func NewWhiskConfig(proppath string, deploymentPath string, manifestPath string,
 
 		}
 		whisk.Debug(whisk.DbgError, errStr)
-		return clientConfig, utils.NewWhiskClientInvalidConfigError(errStr)
+		return clientConfig, wskderrors.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 081e5c4..dbecd0b 100644
--- a/parsers/deploy_parser.go
+++ b/parsers/deploy_parser.go
@@ -20,6 +20,7 @@ package parsers
 import (
 	"github.com/apache/incubator-openwhisk-wskdeploy/utils"
 	"gopkg.in/yaml.v2"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 func (dm *YAMLParser) unmarshalDeployment(input []byte, deploy *YAML) error {
@@ -34,11 +35,11 @@ func (dm *YAMLParser) ParseDeployment(deploymentPath string) (*YAML, error) {
 	dplyyaml := YAML{}
 	content, err := new(utils.ContentReader).LocalReader.ReadLocal(deploymentPath)
     if err != nil {
-        return &dplyyaml, utils.NewFileReadError(deploymentPath, err.Error())
+        return &dplyyaml, wskderrors.NewFileReadError(deploymentPath, err.Error())
     }
 	err = dm.unmarshalDeployment(content, &dplyyaml)
     if err != nil {
-        return &dplyyaml, utils.NewYAMLParserErr(deploymentPath, err)
+        return &dplyyaml, wskderrors.NewYAMLParserErr(deploymentPath, err)
     }
 	dplyyaml.Filepath = deploymentPath
     dplyyamlEnvVar := ReadEnvVariable(&dplyyaml)
diff --git a/parsers/manifest_parser.go b/parsers/manifest_parser.go
index 294d9b7..4cd2a26 100644
--- a/parsers/manifest_parser.go
+++ b/parsers/manifest_parser.go
@@ -31,6 +31,7 @@ import (
 	"github.com/apache/incubator-openwhisk-wskdeploy/utils"
 	"github.com/apache/incubator-openwhisk-wskdeploy/wski18n"
 	"gopkg.in/yaml.v2"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 // Read existing manifest file or create new if none exists
@@ -41,7 +42,7 @@ func ReadOrCreateManifest() (*YAML, error) {
 		dat, _ := ioutil.ReadFile(utils.ManifestFileNameYaml)
 		err := NewYAMLParser().Unmarshal(dat, &maniyaml)
 		if err != nil {
-			return &maniyaml, utils.NewFileReadError(utils.ManifestFileNameYaml, err.Error())
+			return &maniyaml, wskderrors.NewFileReadError(utils.ManifestFileNameYaml, err.Error())
 		}
 	}
 	return &maniyaml, nil
@@ -51,12 +52,12 @@ func ReadOrCreateManifest() (*YAML, error) {
 func Write(manifest *YAML, filename string) error {
 	output, err := NewYAMLParser().marshal(manifest)
 	if err != nil {
-		return utils.NewYAMLFileFormatError(filename, err.Error())
+		return wskderrors.NewYAMLFileFormatError(filename, err.Error())
 	}
 
 	f, err := os.Create(filename)
 	if err != nil {
-		return utils.NewFileReadError(filename, err.Error())
+		return wskderrors.NewFileReadError(filename, err.Error())
 	}
 	defer f.Close()
 
@@ -87,12 +88,12 @@ func (dm *YAMLParser) ParseManifest(manifestPath string) (*YAML, error) {
 
 	content, err := utils.Read(manifestPath)
 	if err != nil {
-		return &maniyaml, utils.NewFileReadError(manifestPath, err.Error())
+		return &maniyaml, wskderrors.NewFileReadError(manifestPath, err.Error())
 	}
 
 	err = mm.Unmarshal(content, &maniyaml)
 	if err != nil {
-		return &maniyaml, utils.NewYAMLParserErr(manifestPath, err)
+		return &maniyaml, wskderrors.NewYAMLParserErr(manifestPath, err)
 	}
 	maniyaml.Filepath = manifestPath
 	manifest := ReadEnvVariable(&maniyaml)
diff --git a/parsers/manifest_parser_test.go b/parsers/manifest_parser_test.go
index 2f1d7fa..b9aca56 100644
--- a/parsers/manifest_parser_test.go
+++ b/parsers/manifest_parser_test.go
@@ -20,7 +20,6 @@
 package parsers
 
 import (
-    "github.com/apache/incubator-openwhisk-wskdeploy/utils"
     "github.com/stretchr/testify/assert"
     "io/ioutil"
     "os"
@@ -31,6 +30,7 @@ import (
     "strconv"
     "strings"
     "github.com/apache/incubator-openwhisk-client-go/whisk"
+    "github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 // Test 1: validate manifest_parser:Unmarshal() method with a sample manifest in NodeJS
@@ -935,7 +935,7 @@ func TestResolveParameterForMultiLineParams(t *testing.T) {
     switch errorType := err.(type) {
     default:
         assert.Fail(t, "Wrong error type received: We are expecting ParserErr.")
-    case *utils.YAMLParserError:
+    case *wskderrors.YAMLParserError:
         assert.Equal(t, "Parameter [name] has an invalid Type. [invalid]", errorType.Message)
     }
 
diff --git a/parsers/parameters.go b/parsers/parameters.go
index 24a389f..41e7a2b 100644
--- a/parsers/parameters.go
+++ b/parsers/parameters.go
@@ -21,6 +21,7 @@ import (
 	"reflect"
 	"encoding/json"
 	"github.com/apache/incubator-openwhisk-wskdeploy/utils"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 // TODO(): Support other valid Package Manifest types
@@ -113,7 +114,7 @@ func ResolveParamTypeFromValue(paramName string, value interface{}, filePath str
 
 		} else {
 			// raise an error if parameter's value is not a known type
-			err = utils.NewInvalidParameterTypeError(filePath, paramName, actualType)
+			err = wskderrors.NewInvalidParameterTypeError(filePath, paramName, actualType)
 		}
 	}
 	return paramType, err
@@ -159,7 +160,7 @@ func resolveSingleLineParameter(filePath string, paramName string, param *Parame
 
 	} else {
 		// TODO() - move string to i18n
-		return param.Value, utils.NewYAMLParserErr(filePath,
+		return param.Value, wskderrors.NewYAMLParserErr(filePath,
 			"Parameter [" + paramName + "] is not single-line format.")
 	}
 
@@ -200,7 +201,7 @@ func resolveMultiLineParameter(filePath string, paramName string, param *Paramet
 		if param.Type != "" {
 			if !isValidParameterType(param.Type) {
 				// TODO() - move string to i18n
-				return param.Value, utils.NewYAMLParserErr(filePath,
+				return param.Value, wskderrors.NewYAMLParserErr(filePath,
 					"Parameter [" + paramName + "] has an invalid Type. [" + param.Type + "]")
 			}
 		} else {
@@ -214,7 +215,7 @@ func resolveMultiLineParameter(filePath string, paramName string, param *Paramet
 		//}
 	} else {
 		// TODO() - move string to i18n
-		return param.Value, utils.NewYAMLParserErr(filePath,
+		return param.Value, wskderrors.NewYAMLParserErr(filePath,
 			"Parameter [" + paramName + "] is not multiline format.")
 	}
 
@@ -265,12 +266,12 @@ func resolveJSONParameter(filePath string, paramName string, param *Parameter, v
 				return temp, errorParser
 			}
 		} else{
-			errorParser = utils.NewParameterTypeMismatchError(filePath, paramName, JSON, param.Type)
+			errorParser = wskderrors.NewParameterTypeMismatchError(filePath, paramName, JSON, param.Type)
 		}
 
 	} else {
 		// TODO() - move string to i18n
-		errorParser = utils.NewYAMLParserErr(filePath, "Parameter [" + paramName + "] is not JSON format.")
+		errorParser = wskderrors.NewYAMLParserErr(filePath, "Parameter [" + paramName + "] is not JSON format.")
 	}
 
 	return param.Value, errorParser
diff --git a/tests/src/integration/common/wskdeploy.go b/tests/src/integration/common/wskdeploy.go
index 3b1fb00..7f9651b 100644
--- a/tests/src/integration/common/wskdeploy.go
+++ b/tests/src/integration/common/wskdeploy.go
@@ -31,6 +31,7 @@ import (
 	"strings"
 	"path/filepath"
 	"path"
+	"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
 )
 
 const (
@@ -120,12 +121,8 @@ func (wskdeploy *Wskdeploy) RunCommand(s ...string) (string, error) {
 
 	var returnError error = nil
 	if err != nil {
-		if len(errb.String()) > 0 {
-			// 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
-		}
+		// Note: (sub-command) is always at Args[0] which is guaranteed to be not empty
+		returnError = wskderrors.NewCommandError(command.Args[0], errb.String())
 	}
 	printOutput(outb.String())
 	if returnError != nil {
diff --git a/utils/wskdeployerror.go b/wskderrors/wskdeployerror.go
similarity index 99%
rename from utils/wskdeployerror.go
rename to wskderrors/wskdeployerror.go
index d5175e8..2d675a3 100644
--- a/utils/wskdeployerror.go
+++ b/wskderrors/wskdeployerror.go
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package utils
+package wskderrors
 
 import (
 	"fmt"
diff --git a/utils/wskdeployerror_test.go b/wskderrors/wskdeployerror_test.go
similarity index 99%
rename from utils/wskdeployerror_test.go
rename to wskderrors/wskdeployerror_test.go
index f9a4cb6..5c7507d 100644
--- a/utils/wskdeployerror_test.go
+++ b/wskderrors/wskdeployerror_test.go
@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 
-package utils
+package wskderrors
 
 import (
 	"testing"
@@ -173,7 +173,6 @@ func TestCustomErrorOutputFormat(t *testing.T) {
 	// TODO add a unit test once we re-factor error related modules into a new package
 	// to avoid cyclic dependency errors in GoLang.
 	//manifestFile := "../tests/dat/manifest_bad_yaml_invalid_comment.yaml"
-	//// read and parse manifest.yaml file
 	//m, err := parsers.NewYAMLParser().ParseManifest(manifestFile)
 	//fmt.Println(err)
 

-- 
To stop receiving notification emails like this one, please contact
['"commits@openwhisk.apache.org" <co...@openwhisk.apache.org>'].