openwhisk-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mrutkow...@apache.org
Subject [incubator-openwhisk-wskdeploy] branch master updated: Create the error type for openwhisk client error (#447)
Date Thu, 07 Sep 2017 15:02:15 GMT
This is an automated email from the ASF dual-hosted git repository.

mrutkowski 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 2f496fc  Create the error type for openwhisk client error (#447)
2f496fc is described below

commit 2f496fcabab1704221537050b6dcbc9cd4d268ad
Author: Vincent <shou@us.ibm.com>
AuthorDate: Thu Sep 7 11:02:13 2017 -0400

    Create the error type for openwhisk client error (#447)
    
    Partially-Closes: #340
---
 deployers/servicedeployer.go     | 1347 +++++++++++++++++++++-----------------
 utils/errorhandlers.go           |    5 +
 utils/misc.go                    |    9 +-
 utils/wskdeployerror.go          |   35 +-
 wski18n/i18n_resources.go        |    4 +-
 wski18n/resources/en_US.all.json |  122 +++-
 6 files changed, 891 insertions(+), 631 deletions(-)

diff --git a/deployers/servicedeployer.go b/deployers/servicedeployer.go
index 4e58c50..02b176a 100644
--- a/deployers/servicedeployer.go
+++ b/deployers/servicedeployer.go
@@ -18,49 +18,49 @@
 package deployers
 
 import (
-	"bufio"
-	"fmt"
-	"os"
-	"path"
-	"strings"
-	"sync"
+    "bufio"
+    "fmt"
+    "os"
+    "path"
+    "strings"
+    "sync"
     "strconv"
 
-	"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-client-go/whisk"
+    "github.com/apache/incubator-openwhisk-wskdeploy/parsers"
+    "github.com/apache/incubator-openwhisk-wskdeploy/utils"
     "github.com/apache/incubator-openwhisk-wskdeploy/wski18n"
 )
 
 type DeploymentApplication struct {
-	Packages map[string]*DeploymentPackage
-	Triggers map[string]*whisk.Trigger
-	Rules    map[string]*whisk.Rule
-	Apis     map[string]*whisk.ApiCreateRequest
+    Packages map[string]*DeploymentPackage
+    Triggers map[string]*whisk.Trigger
+    Rules    map[string]*whisk.Rule
+    Apis     map[string]*whisk.ApiCreateRequest
 }
 
 func NewDeploymentApplication() *DeploymentApplication {
-	var dep DeploymentApplication
-	dep.Packages = make(map[string]*DeploymentPackage)
-	dep.Triggers = make(map[string]*whisk.Trigger)
-	dep.Rules = make(map[string]*whisk.Rule)
-	dep.Apis = make(map[string]*whisk.ApiCreateRequest)
-	return &dep
+    var dep DeploymentApplication
+    dep.Packages = make(map[string]*DeploymentPackage)
+    dep.Triggers = make(map[string]*whisk.Trigger)
+    dep.Rules = make(map[string]*whisk.Rule)
+    dep.Apis = make(map[string]*whisk.ApiCreateRequest)
+    return &dep
 }
 
 type DeploymentPackage struct {
-	Package      *whisk.Package
-	Dependencies map[string]utils.DependencyRecord
-	Actions      map[string]utils.ActionRecord
-	Sequences    map[string]utils.ActionRecord
+    Package      *whisk.Package
+    Dependencies map[string]utils.DependencyRecord
+    Actions      map[string]utils.ActionRecord
+    Sequences    map[string]utils.ActionRecord
 }
 
 func NewDeploymentPackage() *DeploymentPackage {
-	var dep DeploymentPackage
-	dep.Dependencies = make(map[string]utils.DependencyRecord)
-	dep.Actions = make(map[string]utils.ActionRecord)
-	dep.Sequences = make(map[string]utils.ActionRecord)
-	return &dep
+    var dep DeploymentPackage
+    dep.Dependencies = make(map[string]utils.DependencyRecord)
+    dep.Actions = make(map[string]utils.ActionRecord)
+    dep.Sequences = make(map[string]utils.ActionRecord)
+    return &dep
 }
 
 // ServiceDeployer defines a prototype service deployer.
@@ -70,801 +70,916 @@ func NewDeploymentPackage() *DeploymentPackage {
 //   3. Collect information about the source code files in the working directory
 //   4. Create a deployment plan to create OpenWhisk service
 type ServiceDeployer struct {
-	Deployment      *DeploymentApplication
-	Client          *whisk.Client
-	mt              sync.RWMutex
-	RootPackageName string
-	IsInteractive   bool
-	IsDefault       bool
-	ManifestPath    string
-	ProjectPath     string
-	DeploymentPath  string
-	// whether to deploy the action under the package
-	DeployActionInPackage bool
-	InteractiveChoice     bool
-	ClientConfig          *whisk.Config
-	DependencyMaster      map[string]utils.DependencyRecord
+    Deployment      *DeploymentApplication
+    Client          *whisk.Client
+    mt              sync.RWMutex
+    RootPackageName string
+    IsInteractive   bool
+    IsDefault       bool
+    ManifestPath    string
+    ProjectPath     string
+    DeploymentPath  string
+    // whether to deploy the action under the package
+    DeployActionInPackage bool
+    InteractiveChoice     bool
+    ClientConfig          *whisk.Config
+    DependencyMaster      map[string]utils.DependencyRecord
 }
 
 // NewServiceDeployer is a Factory to create a new ServiceDeployer
 func NewServiceDeployer() *ServiceDeployer {
-	var dep ServiceDeployer
-	dep.Deployment = NewDeploymentApplication()
-	dep.IsInteractive = true
-	dep.DeployActionInPackage = true
-	dep.DependencyMaster = make(map[string]utils.DependencyRecord)
+    var dep ServiceDeployer
+    dep.Deployment = NewDeploymentApplication()
+    dep.IsInteractive = true
+    dep.DeployActionInPackage = true
+    dep.DependencyMaster = make(map[string]utils.DependencyRecord)
 
-	return &dep
+    return &dep
 }
 
 // Check if the manifest yaml could be parsed by Manifest Parser.
 // Check if the deployment yaml could be parsed by Manifest Parser.
 func (deployer *ServiceDeployer) Check() {
-	ps := parsers.NewYAMLParser()
-	if utils.FileExists(deployer.DeploymentPath) {
-		ps.ParseDeployment(deployer.DeploymentPath)
-	}
-	ps.ParseManifest(deployer.ManifestPath)
-	// add more schema check or manifest/deployment consistency checks here if
-	// necessary
+    ps := parsers.NewYAMLParser()
+    if utils.FileExists(deployer.DeploymentPath) {
+        ps.ParseDeployment(deployer.DeploymentPath)
+    }
+    ps.ParseManifest(deployer.ManifestPath)
+    // add more schema check or manifest/deployment consistency checks here if
+    // necessary
 }
 
 func (deployer *ServiceDeployer) ConstructDeploymentPlan() error {
 
-	var manifestReader = NewManfiestReader(deployer)
-	manifestReader.IsUndeploy = false
+    var manifestReader = NewManfiestReader(deployer)
+    manifestReader.IsUndeploy = false
     var err error
-	manifest, manifestParser, err := manifestReader.ParseManifest()
-	utils.Check(err)
+    manifest, manifestParser, err := manifestReader.ParseManifest()
+    utils.Check(err)
 
-	deployer.RootPackageName = manifest.Package.Packagename
+    deployer.RootPackageName = manifest.Package.Packagename
 
-	manifestReader.InitRootPackage(manifestParser, manifest)
+    manifestReader.InitRootPackage(manifestParser, manifest)
 
-	if deployer.IsDefault == true {
-		fileReader := NewFileSystemReader(deployer)
-		fileActions, err := fileReader.ReadProjectDirectory(manifest)
-		utils.Check(err)
+    if deployer.IsDefault == true {
+        fileReader := NewFileSystemReader(deployer)
+        fileActions, err := fileReader.ReadProjectDirectory(manifest)
+        utils.Check(err)
 
-		fileReader.SetFileActions(fileActions)
-	}
+        fileReader.SetFileActions(fileActions)
+    }
 
-	// process manifest file
-	err = manifestReader.HandleYaml(deployer, manifestParser, manifest)
-	utils.Check(err)
+    // process manifest file
+    err = manifestReader.HandleYaml(deployer, manifestParser, manifest)
+    utils.Check(err)
 
-	// process deploymet file
-	if utils.FileExists(deployer.DeploymentPath) {
-		var deploymentReader = NewDeploymentReader(deployer)
-		deploymentReader.HandleYaml()
+    // process deploymet file
+    if utils.FileExists(deployer.DeploymentPath) {
+        var deploymentReader = NewDeploymentReader(deployer)
+        deploymentReader.HandleYaml()
 
-		deploymentReader.BindAssets()
-	}
+        deploymentReader.BindAssets()
+    }
 
-	return err
+    return err
 }
 
 func (deployer *ServiceDeployer) ConstructUnDeploymentPlan() (*DeploymentApplication, error) {
 
-	var manifestReader = NewManfiestReader(deployer)
-	manifestReader.IsUndeploy = true
+    var manifestReader = NewManfiestReader(deployer)
+    manifestReader.IsUndeploy = true
     var err error
-	manifest, manifestParser, err := manifestReader.ParseManifest()
-	utils.Check(err)
+    manifest, manifestParser, err := manifestReader.ParseManifest()
+    utils.Check(err)
 
-	manifestReader.InitRootPackage(manifestParser, manifest)
+    manifestReader.InitRootPackage(manifestParser, manifest)
 
-	// process file system
-	if deployer.IsDefault == true {
-		fileReader := NewFileSystemReader(deployer)
-		fileActions, err := fileReader.ReadProjectDirectory(manifest)
-		utils.Check(err)
+    // process file system
+    if deployer.IsDefault == true {
+        fileReader := NewFileSystemReader(deployer)
+        fileActions, err := fileReader.ReadProjectDirectory(manifest)
+        utils.Check(err)
 
-		err = fileReader.SetFileActions(fileActions)
-		utils.Check(err)
+        err = fileReader.SetFileActions(fileActions)
+        utils.Check(err)
 
-	}
+    }
 
-	// process manifest file
-	err = manifestReader.HandleYaml(deployer, manifestParser, manifest)
-	utils.Check(err)
+    // process manifest file
+    err = manifestReader.HandleYaml(deployer, manifestParser, manifest)
+    utils.Check(err)
 
-	// process deployment file
-	if utils.FileExists(deployer.DeploymentPath) {
-		var deploymentReader = NewDeploymentReader(deployer)
-		deploymentReader.HandleYaml()
+    // process deployment file
+    if utils.FileExists(deployer.DeploymentPath) {
+        var deploymentReader = NewDeploymentReader(deployer)
+        deploymentReader.HandleYaml()
 
-		deploymentReader.BindAssets()
-	}
+        deploymentReader.BindAssets()
+    }
 
-	verifiedPlan := deployer.Deployment
+    verifiedPlan := deployer.Deployment
 
-	return verifiedPlan, err
+    return verifiedPlan, err
 }
 
 // Use reflect util to deploy everything in this service deployer
 // TODO(TBD): according to some planning?
 func (deployer *ServiceDeployer) Deploy() error {
 
-	if deployer.IsInteractive == true {
-		deployer.printDeploymentAssets(deployer.Deployment)
-		reader := bufio.NewReader(os.Stdin)
-		fmt.Print("Do you really want to deploy this? (y/N): ")
+    if deployer.IsInteractive == true {
+        deployer.printDeploymentAssets(deployer.Deployment)
+        reader := bufio.NewReader(os.Stdin)
+        fmt.Print("Do you really want to deploy this? (y/N): ")
 
-		text, _ := reader.ReadString('\n')
-		text = strings.TrimSpace(text)
+        text, _ := reader.ReadString('\n')
+        text = strings.TrimSpace(text)
 
-		if text == "" {
-			text = "n"
-		}
+        if text == "" {
+            text = "n"
+        }
 
-		if strings.EqualFold(text, "y") || strings.EqualFold(text, "yes") {
-			deployer.InteractiveChoice = true
-			if err := deployer.deployAssets(); err != nil {
+        if strings.EqualFold(text, "y") || strings.EqualFold(text, "yes") {
+            deployer.InteractiveChoice = true
+            if err := deployer.deployAssets(); err != nil {
                 errString := wski18n.T("Deployment did not complete sucessfully. Run `wskdeploy undeploy` to remove partially deployed assets.\n")
                 whisk.Debug(whisk.DbgError, errString)
-				return err
-			}
+                return err
+            }
 
             utils.PrintOpenWhiskOutput(wski18n.T("Deployment completed successfully.\n"))
             return nil
 
-		} else {
-			deployer.InteractiveChoice = false
-			fmt.Println("OK. Cancelling deployment")
-			return nil
-		}
-	}
+        } else {
+            deployer.InteractiveChoice = false
+            utils.PrintOpenWhiskOutput(wski18n.T("OK. Cancelling deployment.\n"))
+            return nil
+        }
+    }
 
-	// non-interactive
-	if err := deployer.deployAssets(); err != nil {
+    // non-interactive
+    if err := deployer.deployAssets(); err != nil {
         errString := wski18n.T("Deployment did not complete sucessfully. Run `wskdeploy undeploy` to remove partially deployed assets.\n")
         whisk.Debug(whisk.DbgError, errString)
-		return err
-	}
+        return err
+    }
 
     utils.PrintOpenWhiskOutput(wski18n.T("Deployment completed successfully.\n"))
-	return nil
+    return nil
 
 }
 
 func (deployer *ServiceDeployer) deployAssets() error {
 
-	if err := deployer.DeployPackages(); err != nil {
-		return err
-	}
+    if err := deployer.DeployPackages(); err != nil {
+        return err
+    }
 
-	if err := deployer.DeployDependencies(); err != nil {
-		return err
-	}
+    if err := deployer.DeployDependencies(); err != nil {
+        return err
+    }
 
-	if err := deployer.DeployActions(); err != nil {
-		return err
-	}
+    if err := deployer.DeployActions(); err != nil {
+        return err
+    }
 
-	if err := deployer.DeploySequences(); err != nil {
-		return err
-	}
+    if err := deployer.DeploySequences(); err != nil {
+        return err
+    }
 
-	if err := deployer.DeployTriggers(); err != nil {
-		return err
-	}
+    if err := deployer.DeployTriggers(); err != nil {
+        return err
+    }
 
-	if err := deployer.DeployRules(); err != nil {
-		return err
-	}
+    if err := deployer.DeployRules(); err != nil {
+        return err
+    }
 
-	if err := deployer.DeployApis(); err != nil {
-		return err
-	}
+    if err := deployer.DeployApis(); err != nil {
+        return err
+    }
 
 
-	return nil
+    return nil
 }
 
 func (deployer *ServiceDeployer) DeployDependencies() error {
-	for _, pack := range deployer.Deployment.Packages {
-		for depName, depRecord := range pack.Dependencies {
-			fmt.Println("Deploying dependency " + depName + " ... ")
-
-			if depRecord.IsBinding {
-				bindingPackage := new(whisk.BindingPackage)
-				bindingPackage.Namespace = pack.Package.Namespace
-				bindingPackage.Name = depName
-				pub := false
-				bindingPackage.Publish = &pub
-
-				qName, err := utils.ParseQualifiedName(depRecord.Location, pack.Package.Namespace)
-				utils.Check(err)
-				bindingPackage.Binding = whisk.Binding{qName.Namespace, qName.EntityName}
-
-				bindingPackage.Parameters = depRecord.Parameters
-				bindingPackage.Annotations = depRecord.Annotations
-
-				deployer.createBinding(bindingPackage)
-
-			} else {
-				depServiceDeployer, err := deployer.getDependentDeployer(depName, depRecord)
-				utils.Check(err)
-
-				err = depServiceDeployer.ConstructDeploymentPlan()
-				utils.Check(err)
-
-				if err := depServiceDeployer.deployAssets(); err != nil {
-					fmt.Println("\nDeployment of dependency " + depName + " did not complete sucessfully. Run `wskdeploy undeploy` to remove partially deployed assets")
-					return err
-				} else {
-					fmt.Println("Done!")
-				}
-			}
-		}
-	}
+    for _, pack := range deployer.Deployment.Packages {
+        for depName, depRecord := range pack.Dependencies {
+            output := wski18n.T("Deploying dependency {{.output}} ...",
+                map[string]interface{}{"output": depName})
+            whisk.Debug(whisk.DbgInfo, output)
+
+            if depRecord.IsBinding {
+                bindingPackage := new(whisk.BindingPackage)
+                bindingPackage.Namespace = pack.Package.Namespace
+                bindingPackage.Name = depName
+                pub := false
+                bindingPackage.Publish = &pub
+
+                qName, err := utils.ParseQualifiedName(depRecord.Location, pack.Package.Namespace)
+                utils.Check(err)
+                bindingPackage.Binding = whisk.Binding{qName.Namespace, qName.EntityName}
+
+                bindingPackage.Parameters = depRecord.Parameters
+                bindingPackage.Annotations = depRecord.Annotations
+
+                error := deployer.createBinding(bindingPackage)
+                if error != nil {
+                    return error
+                }
+
+            } else {
+                depServiceDeployer, err := deployer.getDependentDeployer(depName, depRecord)
+                utils.Check(err)
+
+                err = depServiceDeployer.ConstructDeploymentPlan()
+                utils.Check(err)
+
+                if err := depServiceDeployer.deployAssets(); err != nil {
+                    errString := wski18n.T("Deployment of dependency {{.depName}} did not complete sucessfully. Run `wskdeploy undeploy` to remove partially deployed assets.\n",
+                        map[string]interface{}{"depName": depName})
+                    utils.PrintOpenWhiskErrorMessage(errString)
+                    return err
+                } else {
+                    fmt.Println("Done!")
+                }
+            }
+        }
+    }
 
-	return nil
+    return nil
 }
 
 func (deployer *ServiceDeployer) DeployPackages() error {
-    var err error
-	for _, pack := range deployer.Deployment.Packages {
-        err = deployer.createPackage(pack.Package)
+    for _, pack := range deployer.Deployment.Packages {
+        err := deployer.createPackage(pack.Package)
         if err != nil {
             return err
         }
-	}
-	return nil
+    }
+    return nil
 }
 
 // Deploy Sequences into OpenWhisk
 func (deployer *ServiceDeployer) DeploySequences() error {
 
-	for _, pack := range deployer.Deployment.Packages {
-		for _, action := range pack.Sequences {
-			deployer.createAction(pack.Package.Name, action.Action)
-		}
-	}
-	return nil
+    for _, pack := range deployer.Deployment.Packages {
+        for _, action := range pack.Sequences {
+            error := deployer.createAction(pack.Package.Name, action.Action)
+            if error != nil {
+                return error
+            }
+        }
+    }
+    return nil
 }
 
 // Deploy Actions into OpenWhisk
 func (deployer *ServiceDeployer) DeployActions() error {
 
-	for _, pack := range deployer.Deployment.Packages {
-		for _, action := range pack.Actions {
-			err := deployer.createAction(pack.Package.Name, action.Action)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
+    for _, pack := range deployer.Deployment.Packages {
+        for _, action := range pack.Actions {
+            err := deployer.createAction(pack.Package.Name, action.Action)
+            if err != nil {
+                return err
+            }
+        }
+    }
+    return nil
 }
 
 // Deploy Triggers into OpenWhisk
 func (deployer *ServiceDeployer) DeployTriggers() error {
-	for _, trigger := range deployer.Deployment.Triggers {
-
-		if feedname, isFeed := utils.IsFeedAction(trigger); isFeed {
-			deployer.createFeedAction(trigger, feedname)
-		} else {
-			deployer.createTrigger(trigger)
-		}
+    for _, trigger := range deployer.Deployment.Triggers {
+
+        if feedname, isFeed := utils.IsFeedAction(trigger); isFeed {
+            error := deployer.createFeedAction(trigger, feedname)
+            if error != nil {
+                return error
+            }
+        } else {
+            error := deployer.createTrigger(trigger)
+            if error != nil {
+                return error
+            }
+        }
 
-	}
-	return nil
+    }
+    return nil
 
 }
 
 // Deploy Rules into OpenWhisk
 func (deployer *ServiceDeployer) DeployRules() error {
-	for _, rule := range deployer.Deployment.Rules {
-		deployer.createRule(rule)
-	}
-	return nil
+    for _, rule := range deployer.Deployment.Rules {
+        error := deployer.createRule(rule)
+        if error != nil {
+            return error
+        }
+    }
+    return nil
 }
 
 // Deploy Apis into OpenWhisk
 func (deployer *ServiceDeployer) DeployApis() error {
-	for _, api := range deployer.Deployment.Apis {
-		deployer.createApi(api)
-	}
-	return nil
+    for _, api := range deployer.Deployment.Apis {
+        error := deployer.createApi(api)
+        if error != nil {
+            return error
+        }
+    }
+    return nil
 }
 
-func (deployer *ServiceDeployer) createBinding(packa *whisk.BindingPackage) {
-	fmt.Print("Deploying package binding " + packa.Name + " ... ")
-	_, _, err := deployer.Client.Packages.Insert(packa, true)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error creating package binding with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	}
-	fmt.Println("Done!")
+func (deployer *ServiceDeployer) createBinding(packa *whisk.BindingPackage) error {
+    output := wski18n.T("Deploying package binding {{.output}} ...",
+        map[string]interface{}{"output": packa.Name})
+    whisk.Debug(whisk.DbgInfo, output)
+    _, _, err := deployer.Client.Packages.Insert(packa, true)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+    }
+    fmt.Println("Done!")
+    return nil
 }
 
 func (deployer *ServiceDeployer) createPackage(packa *whisk.Package) error {
-	fmt.Print("Deploying package " + packa.Name + " ... ")
-	_, _, err := deployer.Client.Packages.Insert(packa, true)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
+    output := wski18n.T("Deploying package {{.output}} ...",
+        map[string]interface{}{"output": packa.Name})
+    whisk.Debug(whisk.DbgInfo, output)
+    _, _, err := deployer.Client.Packages.Insert(packa, true)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
         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 wskErr
-	}
-	fmt.Println("Done!")
+        return utils.NewWhiskClientError(wskErr.Error(), wskErr.ExitCode)
+    }
+    fmt.Println("Done!")
+    return nil
+}
+
+func (deployer *ServiceDeployer) createTrigger(trigger *whisk.Trigger) error {
+    _, _, err := deployer.Client.Triggers.Insert(trigger, true)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+    }
+    fmt.Println("Done!")
+    return nil
+}
+
+func (deployer *ServiceDeployer) createFeedAction(trigger *whisk.Trigger, feedName string) error {
+    output := wski18n.T("Deploying trigger feed {{.output}} ...",
+        map[string]interface{}{"output": trigger.Name})
+    whisk.Debug(whisk.DbgInfo, output)
+    // to hold and modify trigger parameters, not passed by ref?
+    params := make(map[string]interface{})
+
+    // check for strings that are JSON
+    for _, keyVal := range trigger.Parameters {
+        params[keyVal.Key] = keyVal.Value
+    }
+
+    params["authKey"] = deployer.ClientConfig.AuthToken
+    params["lifecycleEvent"] = "CREATE"
+    params["triggerName"] = "/" + deployer.Client.Namespace + "/" + trigger.Name
+
+    pub := true
+    t := &whisk.Trigger{
+        Name:        trigger.Name,
+        Annotations: trigger.Annotations,
+        Publish:     &pub,
+    }
+
+    _, _, err := deployer.Client.Triggers.Insert(t, true)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+    } else {
+
+        qName, err := utils.ParseQualifiedName(feedName, deployer.ClientConfig.Namespace)
+
+        utils.Check(err)
+
+        namespace := deployer.Client.Namespace
+        deployer.Client.Namespace = qName.Namespace
+        _, _, err = deployer.Client.Actions.Invoke(qName.EntityName, params, true, false)
+        deployer.Client.Namespace = namespace
+
+        if err != nil {
+            wskErr := err.(*whisk.WskError)
+            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)
+        }
+    }
+    fmt.Println("Done!")
     return nil
 }
 
-func (deployer *ServiceDeployer) createTrigger(trigger *whisk.Trigger) {
-	_, _, err := deployer.Client.Triggers.Insert(trigger, true)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error creating trigger with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	}
-	fmt.Println("Done!")
-}
-
-func (deployer *ServiceDeployer) createFeedAction(trigger *whisk.Trigger, feedName string) {
-	fmt.Println("Deploying trigger feed " + trigger.Name + " ... ")
-	// to hold and modify trigger parameters, not passed by ref?
-	params := make(map[string]interface{})
-
-	// check for strings that are JSON
-	for _, keyVal := range trigger.Parameters {
-		params[keyVal.Key] = keyVal.Value
-	}
-
-	params["authKey"] = deployer.ClientConfig.AuthToken
-	params["lifecycleEvent"] = "CREATE"
-	params["triggerName"] = "/" + deployer.Client.Namespace + "/" + trigger.Name
-
-	pub := true
-	t := &whisk.Trigger{
-		Name:        trigger.Name,
-		Annotations: trigger.Annotations,
-		Publish:     &pub,
-	}
-
-	_, _, err := deployer.Client.Triggers.Insert(t, true)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error creating trigger with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	} else {
-
-		qName, err := utils.ParseQualifiedName(feedName, deployer.ClientConfig.Namespace)
-
-		utils.Check(err)
-
-		namespace := deployer.Client.Namespace
-		deployer.Client.Namespace = qName.Namespace
-		_, _, err = deployer.Client.Actions.Invoke(qName.EntityName, params, true, false)
-		deployer.Client.Namespace = namespace
-
-		if err != nil {
-			wskErr := err.(*whisk.WskError)
-			fmt.Printf("Got error creating trigger feed with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-		}
-	}
-	fmt.Println("Done!")
-}
-
-func (deployer *ServiceDeployer) createRule(rule *whisk.Rule) {
-	// The rule's trigger should include the namespace with pattern /namespace/trigger
-	rule.Trigger = deployer.getQualifiedName(rule.Trigger.(string), deployer.ClientConfig.Namespace)
-	// The rule's action should include the namespace and package
-	// with pattern /namespace/package/action
-	// TODO(TBD): please refer https://github.com/openwhisk/openwhisk/issues/1577
-
-	// if it contains a slash, then the action is qualified by a package name
-	if strings.Contains(rule.Action.(string), "/") {
-		rule.Action = deployer.getQualifiedName(rule.Action.(string), deployer.ClientConfig.Namespace)
-	} else {
-		// if not, we assume the action is inside the root package
-		rule.Action = deployer.getQualifiedName(strings.Join([]string{deployer.RootPackageName, rule.Action.(string)}, "/"), deployer.ClientConfig.Namespace)
-	}
-	fmt.Print("Deploying rule " + rule.Name + " ... ")
-	_, _, err := deployer.Client.Rules.Insert(rule, true)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error creating rule with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	}
-
-	_, _, err = deployer.Client.Rules.SetState(rule.Name, "active")
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error activating rule with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	}
-	fmt.Println("Done!")
+func (deployer *ServiceDeployer) createRule(rule *whisk.Rule) error {
+    // The rule's trigger should include the namespace with pattern /namespace/trigger
+    rule.Trigger = deployer.getQualifiedName(rule.Trigger.(string), deployer.ClientConfig.Namespace)
+    // The rule's action should include the namespace and package
+    // with pattern /namespace/package/action
+    // TODO(TBD): please refer https://github.com/openwhisk/openwhisk/issues/1577
+
+    // if it contains a slash, then the action is qualified by a package name
+    if strings.Contains(rule.Action.(string), "/") {
+        rule.Action = deployer.getQualifiedName(rule.Action.(string), deployer.ClientConfig.Namespace)
+    } else {
+        // if not, we assume the action is inside the root package
+        rule.Action = deployer.getQualifiedName(strings.Join([]string{deployer.RootPackageName, rule.Action.(string)}, "/"), deployer.ClientConfig.Namespace)
+    }
+    output := wski18n.T("Deploying rule {{.output}} ...",
+        map[string]interface{}{"output": rule.Name})
+    whisk.Debug(whisk.DbgInfo, output)
+
+    _, _, err := deployer.Client.Rules.Insert(rule, true)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+    }
+
+    _, _, err = deployer.Client.Rules.SetState(rule.Name, "active")
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        errString := wski18n.T("Got error setting the status of 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)
+    }
+    fmt.Println("Done!")
+    return nil
 }
 
 // Utility function to call go-whisk framework to make action
 func (deployer *ServiceDeployer) createAction(pkgname string, action *whisk.Action) error {
-	// call ActionService through the Client
-	if deployer.DeployActionInPackage {
-		// the action will be created under package with pattern 'packagename/actionname'
-		action.Name = strings.Join([]string{pkgname, action.Name}, "/")
-	}
-	fmt.Print("Deploying action " + action.Name + " ... ")
-	_, _, err := deployer.Client.Actions.Insert(action, true)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error creating action with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-		return err
-	}
-	fmt.Println("Done!")
-	return nil
+    // call ActionService through the Client
+    if deployer.DeployActionInPackage {
+        // the action will be created under package with pattern 'packagename/actionname'
+        action.Name = strings.Join([]string{pkgname, action.Name}, "/")
+    }
+    output := wski18n.T("Deploying action {{.output}} ...",
+        map[string]interface{}{"output": action.Name})
+    whisk.Debug(whisk.DbgInfo, output)
+
+    _, _, err := deployer.Client.Actions.Insert(action, true)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+    }
+    fmt.Println("Done!")
+    return nil
 }
 
 // create api (API Gateway functionality)
-func (deployer *ServiceDeployer) createApi(api *whisk.ApiCreateRequest) {
-	_, _, err := deployer.Client.Apis.Insert(api, nil, true)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error creating api with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	}
-	fmt.Println("Done!")
+func (deployer *ServiceDeployer) createApi(api *whisk.ApiCreateRequest) error {
+    _, _, err := deployer.Client.Apis.Insert(api, nil, true)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+    }
+    fmt.Println("Done!")
+    return nil
 }
 
 func (deployer *ServiceDeployer) UnDeploy(verifiedPlan *DeploymentApplication) error {
-	if deployer.IsInteractive == true {
-		deployer.printDeploymentAssets(verifiedPlan)
-		reader := bufio.NewReader(os.Stdin)
+    if deployer.IsInteractive == true {
+        deployer.printDeploymentAssets(verifiedPlan)
+        reader := bufio.NewReader(os.Stdin)
 
-		fmt.Print("Do you really want to undeploy this? (y/N): ")
+        fmt.Print("Do you really want to undeploy this? (y/N): ")
 
-		text, _ := reader.ReadString('\n')
-		text = strings.TrimSpace(text)
+        text, _ := reader.ReadString('\n')
+        text = strings.TrimSpace(text)
 
-		if text == "" {
-			text = "n"
-		}
+        if text == "" {
+            text = "n"
+        }
 
-		if strings.EqualFold(text, "y") || strings.EqualFold(text, "yes") {
-			deployer.InteractiveChoice = true
+        if strings.EqualFold(text, "y") || strings.EqualFold(text, "yes") {
+            deployer.InteractiveChoice = true
 
-			if err := deployer.unDeployAssets(verifiedPlan); err != nil {
-				fmt.Println("\nUndeployment did not complete sucessfully.")
-				return err
-			}
+            if err := deployer.unDeployAssets(verifiedPlan); err != nil {
+                utils.PrintOpenWhiskErrorMessage(wski18n.T("Undeployment did not complete sucessfully.\n"))
+                return err
+            }
 
-			fmt.Println("\nDeployment removed successfully.")
-			return nil
+            utils.PrintOpenWhiskOutput(wski18n.T("Deployment removed successfully.\n"))
+            return nil
 
-		} else {
-			deployer.InteractiveChoice = false
-			fmt.Println("OK. Canceling undeployment")
-			return nil
-		}
-	}
+        } else {
+            deployer.InteractiveChoice = false
+            utils.PrintOpenWhiskOutput(wski18n.T("OK. Canceling undeployment.\n"))
+            return nil
+        }
+    }
 
-	// non-interactive
-	if err := deployer.unDeployAssets(verifiedPlan); err != nil {
-		fmt.Println("\nUndeployment did not complete sucessfully.")
-		return err
-	}
+    // non-interactive
+    if err := deployer.unDeployAssets(verifiedPlan); err != nil {
+        errString := wski18n.T("Undeployment did not complete sucessfully.\n")
+        whisk.Debug(whisk.DbgError, errString)
+        return err
+    }
 
-	fmt.Println("\nDeployment removed successfully.")
-	return nil
+    utils.PrintOpenWhiskOutput(wski18n.T("Deployment removed successfully.\n"))
+    return nil
 
 }
 
 func (deployer *ServiceDeployer) unDeployAssets(verifiedPlan *DeploymentApplication) error {
 
-	if err := deployer.UnDeployActions(verifiedPlan); err != nil {
-		return err
-	}
+    if err := deployer.UnDeployActions(verifiedPlan); err != nil {
+        return err
+    }
 
-	if err := deployer.UnDeploySequences(verifiedPlan); err != nil {
-		return err
-	}
+    if err := deployer.UnDeploySequences(verifiedPlan); err != nil {
+        return err
+    }
 
-	if err := deployer.UnDeployTriggers(verifiedPlan); err != nil {
-		return err
-	}
+    if err := deployer.UnDeployTriggers(verifiedPlan); err != nil {
+        return err
+    }
 
-	if err := deployer.UnDeployRules(verifiedPlan); err != nil {
-		return err
-	}
+    if err := deployer.UnDeployRules(verifiedPlan); err != nil {
+        return err
+    }
 
-	if err := deployer.UnDeployPackages(verifiedPlan); err != nil {
-		return err
-	}
+    if err := deployer.UnDeployPackages(verifiedPlan); err != nil {
+        return err
+    }
 
-	if err := deployer.UnDeployDependencies(); err != nil {
-		return err
-	}
+    if err := deployer.UnDeployDependencies(); err != nil {
+        return err
+    }
 
-	return nil
+    return nil
 
 }
 
 func (deployer *ServiceDeployer) UnDeployDependencies() error {
-	for _, pack := range deployer.Deployment.Packages {
-		for depName, depRecord := range pack.Dependencies {
-			fmt.Println("Undeploying dependency " + depName + " ... ")
-
-			if depRecord.IsBinding {
-				_, err := deployer.Client.Packages.Delete(depName)
-				utils.Check(err)
-			} else {
-
-				depServiceDeployer, err := deployer.getDependentDeployer(depName, depRecord)
-				utils.Check(err)
-
-				plan, err := depServiceDeployer.ConstructUnDeploymentPlan()
-				utils.Check(err)
-
-				if err := depServiceDeployer.unDeployAssets(plan); err != nil {
-					fmt.Println("\nUndeployment of dependency " + depName + " did not complete sucessfully. Run `wskdeploy undeploy` to remove partially deployed assets")
-					return err
-				} else {
-					fmt.Println("Done!")
-				}
-			}
-		}
-	}
+    for _, pack := range deployer.Deployment.Packages {
+        for depName, depRecord := range pack.Dependencies {
+            output := wski18n.T("Undeploying dependency {{.depName}} ...",
+                map[string]interface{}{"depName": depName})
+            whisk.Debug(whisk.DbgInfo, output)
+
+            if depRecord.IsBinding {
+                _, err := deployer.Client.Packages.Delete(depName)
+                utils.Check(err)
+            } else {
+
+                depServiceDeployer, err := deployer.getDependentDeployer(depName, depRecord)
+                utils.Check(err)
+
+                plan, err := depServiceDeployer.ConstructUnDeploymentPlan()
+                utils.Check(err)
+
+                if err := depServiceDeployer.unDeployAssets(plan); err != nil {
+                    errString := wski18n.T("Undeployment of dependency {{.depName}} did not complete sucessfully.\n",
+                        map[string]interface{}{"depName": depName})
+                    whisk.Debug(whisk.DbgError, errString)
+                    return err
+                } else {
+                    fmt.Println("Done!")
+                }
+            }
+        }
+    }
 
-	return nil
+    return nil
 }
 
 func (deployer *ServiceDeployer) UnDeployPackages(deployment *DeploymentApplication) error {
-	for _, pack := range deployment.Packages {
-		deployer.deletePackage(pack.Package)
-	}
-	return nil
+    for _, pack := range deployment.Packages {
+        err := deployer.deletePackage(pack.Package)
+        if err != nil {
+            return err
+        }
+    }
+    return nil
 }
 
 func (deployer *ServiceDeployer) UnDeploySequences(deployment *DeploymentApplication) error {
 
-	for _, pack := range deployment.Packages {
-		for _, action := range pack.Sequences {
-			deployer.deleteAction(pack.Package.Name, action.Action)
-		}
-	}
-	return nil
+    for _, pack := range deployment.Packages {
+        for _, action := range pack.Sequences {
+            err := deployer.deleteAction(pack.Package.Name, action.Action)
+            if err != nil {
+                return err
+            }
+        }
+    }
+    return nil
 }
 
 // DeployActions into OpenWhisk
 func (deployer *ServiceDeployer) UnDeployActions(deployment *DeploymentApplication) error {
 
-	for _, pack := range deployment.Packages {
-		for _, action := range pack.Actions {
-			err := deployer.deleteAction(pack.Package.Name, action.Action)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
+    for _, pack := range deployment.Packages {
+        for _, action := range pack.Actions {
+            err := deployer.deleteAction(pack.Package.Name, action.Action)
+            if err != nil {
+                return err
+            }
+        }
+    }
+    return nil
 }
 
 // Deploy Triggers into OpenWhisk
 func (deployer *ServiceDeployer) UnDeployTriggers(deployment *DeploymentApplication) error {
 
-	for _, trigger := range deployment.Triggers {
-		if feedname, isFeed := utils.IsFeedAction(trigger); isFeed {
-			deployer.deleteFeedAction(trigger, feedname)
-		} else {
-			deployer.deleteTrigger(trigger)
-		}
-	}
+    for _, trigger := range deployment.Triggers {
+        if feedname, isFeed := utils.IsFeedAction(trigger); isFeed {
+            err := deployer.deleteFeedAction(trigger, feedname)
+            if err != nil {
+                return err
+            }
+        } else {
+            err := deployer.deleteTrigger(trigger)
+            if err != nil {
+                return err
+            }
+        }
+    }
 
-	return nil
+    return nil
 
 }
 
 // Deploy Rules into OpenWhisk
 func (deployer *ServiceDeployer) UnDeployRules(deployment *DeploymentApplication) error {
 
-	for _, rule := range deployment.Rules {
-		deployer.deleteRule(rule)
-
-	}
-	return nil
+    for _, rule := range deployment.Rules {
+        err := deployer.deleteRule(rule)
+        if err != nil {
+            return err
+        }
+    }
+    return nil
 }
 
-func (deployer *ServiceDeployer) deletePackage(packa *whisk.Package) {
-	fmt.Print("Removing package " + packa.Name + " ... ")
-	_, err := deployer.Client.Packages.Delete(packa.Name)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error deleteing package with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	}
-	fmt.Println("Done!")
+func (deployer *ServiceDeployer) deletePackage(packa *whisk.Package) error {
+    output := wski18n.T("Removing package {{.package}} ...",
+        map[string]interface{}{"package": packa.Name})
+    whisk.Debug(whisk.DbgInfo, output)
+    _, err := deployer.Client.Packages.Delete(packa.Name)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+    }
+    fmt.Println("Done!")
+    return nil
 }
 
-func (deployer *ServiceDeployer) deleteTrigger(trigger *whisk.Trigger) {
-	fmt.Print("Removing trigger " + trigger.Name + " ... ")
-	_, _, err := deployer.Client.Triggers.Delete(trigger.Name)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error deleting trigger with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	}
-	fmt.Println("Done!")
+func (deployer *ServiceDeployer) deleteTrigger(trigger *whisk.Trigger) error {
+    output := wski18n.T("Removing trigger {{.trigger}} ...",
+        map[string]interface{}{"trigger": trigger.Name})
+    whisk.Debug(whisk.DbgInfo, output)
+    _, _, err := deployer.Client.Triggers.Delete(trigger.Name)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+    }
+    fmt.Println("Done!")
+    return nil
 }
 
-func (deployer *ServiceDeployer) deleteFeedAction(trigger *whisk.Trigger, feedName string) {
+func (deployer *ServiceDeployer) deleteFeedAction(trigger *whisk.Trigger, feedName string) error {
 
-	params := make(whisk.KeyValueArr, 0)
-	params = append(params, whisk.KeyValue{Key: "authKey", Value: deployer.ClientConfig.AuthToken})
-	params = append(params, whisk.KeyValue{Key: "lifecycleEvent", Value: "DELETE"})
-	params = append(params, whisk.KeyValue{Key: "triggerName", Value: "/" + deployer.Client.Namespace + "/" + trigger.Name})
+    params := make(whisk.KeyValueArr, 0)
+    params = append(params, whisk.KeyValue{Key: "authKey", Value: deployer.ClientConfig.AuthToken})
+    params = append(params, whisk.KeyValue{Key: "lifecycleEvent", Value: "DELETE"})
+    params = append(params, whisk.KeyValue{Key: "triggerName", Value: "/" + deployer.Client.Namespace + "/" + trigger.Name})
 
-	trigger.Parameters = nil
+    trigger.Parameters = nil
+
+    _, _, err := deployer.Client.Triggers.Delete(trigger.Name)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+    } else {
+        parameters := make(map[string]interface{})
+        for _, keyVal := range params {
+            parameters[keyVal.Key] = keyVal.Value
+        }
 
-	_, _, err := deployer.Client.Triggers.Delete(trigger.Name)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error deleting trigger with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	} else {
-		parameters := make(map[string]interface{})
-		for _, keyVal := range params {
-			parameters[keyVal.Key] = keyVal.Value
-		}
+        qName, err := utils.ParseQualifiedName(feedName, deployer.ClientConfig.Namespace)
 
-		qName, err := utils.ParseQualifiedName(feedName, deployer.ClientConfig.Namespace)
+        utils.Check(err)
 
-		utils.Check(err)
+        namespace := deployer.Client.Namespace
+        deployer.Client.Namespace = qName.Namespace
+        _, _, err = deployer.Client.Actions.Invoke(qName.EntityName, parameters, true, true)
+        deployer.Client.Namespace = namespace
 
-		namespace := deployer.Client.Namespace
-		deployer.Client.Namespace = qName.Namespace
-		_, _, err = deployer.Client.Actions.Invoke(qName.EntityName, parameters, true, true)
-		deployer.Client.Namespace = namespace
+        if err != nil {
+            wskErr := err.(*whisk.WskError)
+            errString := wski18n.T("Got error 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)
 
-		if err != nil {
-			wskErr := err.(*whisk.WskError)
-			fmt.Printf("Got error deleting trigger feed with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-		}
-	}
-	fmt.Println("Done!")
+        }
+    }
+    fmt.Println("Done!")
+    return nil
 }
 
-func (deployer *ServiceDeployer) deleteRule(rule *whisk.Rule) {
-	fmt.Print("Removing rule " + rule.Name + " ... ")
-	_, _, err := deployer.Client.Rules.SetState(rule.Name, "inactive")
+func (deployer *ServiceDeployer) deleteRule(rule *whisk.Rule) error {
+    output := wski18n.T("Removing rule {{.rule}} ...",
+        map[string]interface{}{"rule": rule.Name})
+    whisk.Debug(whisk.DbgInfo, output)
+    _, _, err := deployer.Client.Rules.SetState(rule.Name, "inactive")
 
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error deleting rule with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-	} else {
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        errString := wski18n.T("Got error setting the status of 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)
+    } else {
 
-		_, err = deployer.Client.Rules.Delete(rule.Name)
+        _, err = deployer.Client.Rules.Delete(rule.Name)
 
-		if err != nil {
-			wskErr := err.(*whisk.WskError)
-			fmt.Printf("Got error deleting rule with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-		}
+        if err != nil {
+            wskErr := err.(*whisk.WskError)
+            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)
+        }
 
-		fmt.Println("Done!")
-	}
+        fmt.Println("Done!")
+    }
+    return nil
 }
 
 // Utility function to call go-whisk framework to make action
 func (deployer *ServiceDeployer) deleteAction(pkgname string, action *whisk.Action) error {
-	// call ActionService Thru Client
-	if deployer.DeployActionInPackage {
-		// the action will be deleted under package with pattern 'packagename/actionname'
-		action.Name = strings.Join([]string{pkgname, action.Name}, "/")
-	}
-
-	fmt.Print("Removing action " + action.Name + " ... ")
-	_, err := deployer.Client.Actions.Delete(action.Name)
-	if err != nil {
-		wskErr := err.(*whisk.WskError)
-		fmt.Printf("Got error deleting action with error message: %v and error code: %v.\n", wskErr.Error(), wskErr.ExitCode)
-		return err
-	}
-	fmt.Println("Done!")
-	return nil
+    // call ActionService Thru Client
+    if deployer.DeployActionInPackage {
+        // the action will be deleted under package with pattern 'packagename/actionname'
+        action.Name = strings.Join([]string{pkgname, action.Name}, "/")
+    }
+
+    output := wski18n.T("Removing action {{.action}} ...",
+        map[string]interface{}{"action": action.Name})
+    whisk.Debug(whisk.DbgInfo, output)
+
+    _, err := deployer.Client.Actions.Delete(action.Name)
+    if err != nil {
+        wskErr := err.(*whisk.WskError)
+        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)
+
+    }
+    fmt.Println("Done!")
+    return nil
 }
 
 // from whisk go client
 func (deployer *ServiceDeployer) getQualifiedName(name string, namespace string) string {
-	if strings.HasPrefix(name, "/") {
-		return name
-	} else if strings.HasPrefix(namespace, "/") {
-		return fmt.Sprintf("%s/%s", namespace, name)
-	} else {
-		if len(namespace) == 0 {
-			namespace = deployer.ClientConfig.Namespace
-		}
-		return fmt.Sprintf("/%s/%s", namespace, name)
-	}
+    if strings.HasPrefix(name, "/") {
+        return name
+    } else if strings.HasPrefix(namespace, "/") {
+        return fmt.Sprintf("%s/%s", namespace, name)
+    } else {
+        if len(namespace) == 0 {
+            namespace = deployer.ClientConfig.Namespace
+        }
+        return fmt.Sprintf("/%s/%s", namespace, name)
+    }
 }
 
 func (deployer *ServiceDeployer) printDeploymentAssets(assets *DeploymentApplication) {
 
-	// pretty ASCII OpenWhisk graphic
-	fmt.Println("         ____      ___                   _    _ _     _     _\n        /\\   \\    / _ \\ _ __   ___ _ __ | |  | | |__ (_)___| | __\n   /\\  /__\\   \\  | | | | '_ \\ / _ \\ '_ \\| |  | | '_ \\| / __| |/ /\n  /  \\____ \\  /  | |_| | |_) |  __/ | | | |/\\| | | | | \\__ \\   <\n  \\   \\  /  \\/    \\___/| .__/ \\___|_| |_|__/\\__|_| |_|_|___/_|\\_\\ \n   \\___\\/              |_|\n")
-
-	fmt.Println("Packages:")
-	for _, pack := range assets.Packages {
-		fmt.Println("Name: " + pack.Package.Name)
-		fmt.Println("    bindings: ")
-		for _, p := range pack.Package.Parameters {
-			fmt.Printf("        - %s : %v\n", p.Key, utils.PrettyJSON(p.Value))
-		}
-
-		for key, dep := range pack.Dependencies {
-			fmt.Println("  * dependency: " + key)
-			fmt.Println("    location: " + dep.Location)
-			if !dep.IsBinding {
-				fmt.Println("    local path: " + dep.ProjectPath)
-			}
-		}
-
-		fmt.Println("")
-
-		for _, action := range pack.Actions {
-			fmt.Println("  * action: " + action.Action.Name)
-			fmt.Println("    bindings: ")
-			for _, p := range action.Action.Parameters {
-				fmt.Printf("        - %s : %v\n", p.Key, utils.PrettyJSON(p.Value))
-			}
-			fmt.Println("    annotations: ")
-			for _, p := range action.Action.Annotations {
-				fmt.Printf("        - %s : %v\n", p.Key, p.Value)
-
-			}
-		}
-
-		fmt.Println("")
-		for _, action := range pack.Sequences {
-			fmt.Println("  * sequence: " + action.Action.Name)
-		}
-
-		fmt.Println("")
-	}
-
-	fmt.Println("Triggers:")
-	for _, trigger := range assets.Triggers {
-		fmt.Println("* trigger: " + trigger.Name)
-		fmt.Println("    bindings: ")
-
-		for _, p := range trigger.Parameters {
-			fmt.Printf("        - %s : %v\n", p.Key, utils.PrettyJSON(p.Value))
-		}
-
-		fmt.Println("    annotations: ")
-		for _, p := range trigger.Annotations {
-
-			value := "?"
-			if str, ok := p.Value.(string); ok {
-				value = str
-			}
-			fmt.Println("        - name: " + p.Key + " value: " + value)
-		}
-	}
-
-	fmt.Println("\n Rules")
-	for _, rule := range assets.Rules {
-		fmt.Println("* rule: " + rule.Name)
-		fmt.Println("    - trigger: " + rule.Trigger.(string) + "\n    - action: " + rule.Action.(string))
-	}
-
-	fmt.Println("")
+    // pretty ASCII OpenWhisk graphic
+    fmt.Println("         ____      ___                   _    _ _     _     _\n        /\\   \\    / _ \\ _ __   ___ _ __ | |  | | |__ (_)___| | __\n   /\\  /__\\   \\  | | | | '_ \\ / _ \\ '_ \\| |  | | '_ \\| / __| |/ /\n  /  \\____ \\  /  | |_| | |_) |  __/ | | | |/\\| | | | | \\__ \\   <\n  \\   \\  /  \\/    \\___/| .__/ \\___|_| |_|__/\\__|_| |_|_|___/_|\\_\\ \n   \\___\\/              |_|\n")
+
+    fmt.Println("Packages:")
+    for _, pack := range assets.Packages {
+        fmt.Println("Name: " + pack.Package.Name)
+        fmt.Println("    bindings: ")
+        for _, p := range pack.Package.Parameters {
+            fmt.Printf("        - %s : %v\n", p.Key, utils.PrettyJSON(p.Value))
+        }
+
+        for key, dep := range pack.Dependencies {
+            fmt.Println("  * dependency: " + key)
+            fmt.Println("    location: " + dep.Location)
+            if !dep.IsBinding {
+                fmt.Println("    local path: " + dep.ProjectPath)
+            }
+        }
+
+        fmt.Println("")
+
+        for _, action := range pack.Actions {
+            fmt.Println("  * action: " + action.Action.Name)
+            fmt.Println("    bindings: ")
+            for _, p := range action.Action.Parameters {
+                fmt.Printf("        - %s : %v\n", p.Key, utils.PrettyJSON(p.Value))
+            }
+            fmt.Println("    annotations: ")
+            for _, p := range action.Action.Annotations {
+                fmt.Printf("        - %s : %v\n", p.Key, p.Value)
+
+            }
+        }
+
+        fmt.Println("")
+        for _, action := range pack.Sequences {
+            fmt.Println("  * sequence: " + action.Action.Name)
+        }
+
+        fmt.Println("")
+    }
+
+    fmt.Println("Triggers:")
+    for _, trigger := range assets.Triggers {
+        fmt.Println("* trigger: " + trigger.Name)
+        fmt.Println("    bindings: ")
+
+        for _, p := range trigger.Parameters {
+            fmt.Printf("        - %s : %v\n", p.Key, utils.PrettyJSON(p.Value))
+        }
+
+        fmt.Println("    annotations: ")
+        for _, p := range trigger.Annotations {
+
+            value := "?"
+            if str, ok := p.Value.(string); ok {
+                value = str
+            }
+            fmt.Println("        - name: " + p.Key + " value: " + value)
+        }
+    }
+
+    fmt.Println("\n Rules")
+    for _, rule := range assets.Rules {
+        fmt.Println("* rule: " + rule.Name)
+        fmt.Println("    - trigger: " + rule.Trigger.(string) + "\n    - action: " + rule.Action.(string))
+    }
+
+    fmt.Println("")
 
 }
 
 func (deployer *ServiceDeployer) getDependentDeployer(depName string, depRecord utils.DependencyRecord) (*ServiceDeployer, error) {
-	depServiceDeployer := NewServiceDeployer()
-	projectPath := path.Join(depRecord.ProjectPath, depName+"-"+depRecord.Version)
-	if len(depRecord.SubFolder)>0 {
-		projectPath = path.Join(projectPath,depRecord.SubFolder)
-	}
-	manifestPath := utils.GetManifestFilePath(projectPath)
-	deploymentPath := utils.GetDeploymentFilePath(projectPath)
-	depServiceDeployer.ProjectPath = projectPath
-	depServiceDeployer.ManifestPath = manifestPath
-	depServiceDeployer.DeploymentPath = deploymentPath
-	depServiceDeployer.IsInteractive = true
-
-	depServiceDeployer.Client = deployer.Client
-	depServiceDeployer.ClientConfig = deployer.ClientConfig
-
-	depServiceDeployer.DependencyMaster = deployer.DependencyMaster
-
-	// share the master dependency list
-	depServiceDeployer.DependencyMaster = deployer.DependencyMaster
-
-	return depServiceDeployer, nil
+    depServiceDeployer := NewServiceDeployer()
+    projectPath := path.Join(depRecord.ProjectPath, depName+"-"+depRecord.Version)
+    if len(depRecord.SubFolder)>0 {
+        projectPath = path.Join(projectPath,depRecord.SubFolder)
+    }
+    manifestPath := utils.GetManifestFilePath(projectPath)
+    deploymentPath := utils.GetDeploymentFilePath(projectPath)
+    depServiceDeployer.ProjectPath = projectPath
+    depServiceDeployer.ManifestPath = manifestPath
+    depServiceDeployer.DeploymentPath = deploymentPath
+    depServiceDeployer.IsInteractive = true
+
+    depServiceDeployer.Client = deployer.Client
+    depServiceDeployer.ClientConfig = deployer.ClientConfig
+
+    depServiceDeployer.DependencyMaster = deployer.DependencyMaster
+
+    // share the master dependency list
+    depServiceDeployer.DependencyMaster = deployer.DependencyMaster
+
+    return depServiceDeployer, nil
 }
diff --git a/utils/errorhandlers.go b/utils/errorhandlers.go
index db53d88..a20fb29 100644
--- a/utils/errorhandlers.go
+++ b/utils/errorhandlers.go
@@ -56,3 +56,8 @@ func PrintOpenWhiskOutput(output string) {
     outputStream := colorable.NewColorableStdout()
     fmt.Fprintf(outputStream, "%s", color.GreenString(output))
 }
+
+func PrintOpenWhiskErrorMessage(err string) {
+    outputStream := colorable.NewColorableStderr()
+    fmt.Fprintf(outputStream, "%s", color.RedString(err))
+}
diff --git a/utils/misc.go b/utils/misc.go
index 56ae3bd..fd570b3 100644
--- a/utils/misc.go
+++ b/utils/misc.go
@@ -474,20 +474,19 @@ func ParseOpenWhisk(apiHost string) (op OpenWhiskInfo, err error) {
     }
 
 	// Local openwhisk deployment sometimes only returns "application/json" as the content type
-    openWhiskInfo := OpenWhiskInfo{}
 	if err != nil || !strings.Contains(ct, res.Header.Get("Content-Type")) {
         stdout := wski18n.T("Start to unmarshal Openwhisk info from local values.\n")
         whisk.Debug(whisk.DbgInfo, stdout)
-		err = json.Unmarshal(runtimeInfo, &openWhiskInfo)
+		err = json.Unmarshal(runtimeInfo, &op)
 	} else {
 		b, _ := ioutil.ReadAll(res.Body)
 		if b != nil && len(b) > 0 {
             stdout := wski18n.T("Unmarshal Openwhisk info from internet.\n")
             whisk.Debug(whisk.DbgInfo, stdout)
-			err = json.Unmarshal(b, &openWhiskInfo)
+			err = json.Unmarshal(b, &op)
 		}
 	}
-	return openWhiskInfo, err
+	return
 }
 
 func ConvertToMap(op OpenWhiskInfo) (rt map[string][]string) {
@@ -500,7 +499,7 @@ func ConvertToMap(op OpenWhiskInfo) (rt map[string][]string) {
 			}
 		}
 	}
-	return rt
+	return
 }
 
 var runtimeInfo = []byte(`{
diff --git a/utils/wskdeployerror.go b/utils/wskdeployerror.go
index a942f22..1062c7f 100644
--- a/utils/wskdeployerror.go
+++ b/utils/wskdeployerror.go
@@ -24,21 +24,22 @@ import (
 )
 
 const (
-	INVALID_YAML_INPUT = "Invalid input of Yaml file"
+    INVALID_YAML_INPUT = "Invalid input of Yaml file"
+    OPENWHISK_CLIENT_ERROR = "OpenWhisk Client Error"
 )
 
 type TestCaseError struct {
-	errorMessage string
+    errorMessage string
 }
 
 func NewTestCaseError(errorMessage string) *TestCaseError {
-	return &TestCaseError{
-		errorMessage: errorMessage,
-	}
+    return &TestCaseError{
+        errorMessage: errorMessage,
+    }
 }
 
 func (e *TestCaseError) Error() string {
-	return e.errorMessage
+    return e.errorMessage
 }
 
 type BaseErr struct {
@@ -83,6 +84,28 @@ func (e *InputYamlFileError) Error() string {
     return fmt.Sprintf("%s [%d]: %s =====> %s", e.FileName, e.LineNum, e.errorType, e.Message)
 }
 
+type WhiskClientError struct {
+    BaseErr
+    errorType string
+    errorCode int
+}
+
+func NewWhiskClientError(errMessage string, code int) *WhiskClientError {
+    _, fn, lineNum, _ := runtime.Caller(1)
+    var err = &WhiskClientError{
+        errorType: wski18n.T(OPENWHISK_CLIENT_ERROR),
+        errorCode: code,
+    }
+    err.SetFileName(fn)
+    err.SetLineNum(lineNum)
+    err.SetMessage(errMessage)
+    return err
+}
+
+func (e *WhiskClientError) Error() string {
+    return fmt.Sprintf("%s [%d]: %s =====> %s Error code: %d.", e.FileName, e.LineNum, e.errorType, e.Message, e.errorCode)
+}
+
 type InvalidWskpropsError struct {
     BaseErr
 }
diff --git a/wski18n/i18n_resources.go b/wski18n/i18n_resources.go
index 05a77c6..ce202fa 100644
--- a/wski18n/i18n_resources.go
+++ b/wski18n/i18n_resources.go
@@ -114,7 +114,7 @@ func wski18nResourcesDe_deAllJson() (*asset, error) {
     return a, nil
 }
 
-var _wski18nResourcesEn_usAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x95\xdf\x6f\xd3\x30\x10\xc7\xdf\xf3\x57\x9c\xfa\xb2\x97\xa9\xbc\xef\x6d\x12\x83\x4d\x08\x36\xb1\x01\x42\x80\x54\x63\x5f\x1a\x53\xff\x92\x7d\xee\x54\xa2\xfc\xef\xc8\x49\x1b\xaa\xe2\xa4\x69\x81\x37\xc7\xbe\xfb\x7c\xbf\xf6\xd9\x97\x2f\x05\x40\x5d\x00\x00\xcc\xa4\x98\x5d\xc1\xec\x16\x95\xb2\xb3\xcb\x6e\x8a\x3c\x33\x41\x31\x92\xd6\xa4\xb5\x6b\x03\xd7\x0f\x77\x50\xd9\x40\xa0\x63\x20\xf8\x8e\xe0\xbc\x5d\x4b [...]
+var _wski18nResourcesEn_usAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x58\x4d\x8f\xdb\x36\x10\xbd\xeb\x57\x0c\x7c\xc9\x25\x50\xef\xb9\x05\xe9\xb6\x59\x04\xcd\x06\xd9\xb4\x45\xd0\x16\x30\x23\x8e\x2c\xd6\x14\x29\x90\x43\x2f\x5c\x41\xff\xbd\xa0\x64\x7b\x37\x1b\x91\xa2\xfc\x85\x14\xe8\x4d\x12\xf9\xde\x9b\xe1\x90\x33\x1c\xfd\x91\x01\xb4\x19\x00\xc0\x42\xf0\xc5\x2b\x58\xbc\x45\x29\xf5\xe2\xe5\xf0\x89\x0c\x53\x56\x32\x12\x5a\xf9\xb1\xd7\x0a\x5e\x7f\xb8\x85\x4a\x5b\x82\xda\x59 [...]
 
 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: 2688, mode: os.FileMode(420), modTime: time.Unix(1504645143, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/en_US.all.json", size: 7592, mode: os.FileMode(420), modTime: time.Unix(1504712756, 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 a372cf4..cdf8f73 100644
--- a/wski18n/resources/en_US.all.json
+++ b/wski18n/resources/en_US.all.json
@@ -12,8 +12,8 @@
     "translation": "Missing manifest.yaml file"
   },
   {
-  "id": "authorization `KEY`",
-  "translation": "authorization `KEY`"
+    "id": "authorization `KEY`",
+    "translation": "authorization `KEY`"
   },
   {
     "id": "whisk API `HOST`",
@@ -89,5 +89,123 @@
   {
     "id": "Got error creating package with error message: {{.err}} and error code: {{.code}}.\n",
     "translation": "Got error creating package with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error creating action with error message: {{.err}} and error code: {{.code}}.\n",
+    "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"
+  },
+  {
+    "id": "Got error creating rule with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error creating rule with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error setting the status of rule with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error setting the status of rule with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error creating trigger with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error creating trigger with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error creating trigger feed with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error creating trigger feed with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error creating package binding with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error creating package binding with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Deployment of dependency {{.depName}} did not complete sucessfully. Run `wskdeploy undeploy` to remove partially deployed assets.\n",
+    "translation": "Deployment of dependency {{.depName}} did not complete sucessfully. Run `wskdeploy undeploy` to remove partially deployed assets.\n"
+  },
+  {
+    "id": "Deploying action {{.output}} ...",
+    "translation": "Deploying action {{.output}} ..."
+  },
+  {
+    "id": "Deploying rule {{.output}} ...",
+    "translation": "Deploying rule {{.output}} ..."
+  },
+  {
+    "id": "Deploying trigger feed {{.output}} ...",
+    "translation": "Deploying trigger feed {{.output}} ..."
+  },
+  {
+    "id": "Deploying package {{.output}} ...",
+    "translation": "Deploying package {{.output}} ..."
+  },
+  {
+    "id": "Deploying package binding {{.output}} ...",
+    "translation": "Deploying package binding {{.output}} ..."
+  },
+  {
+    "id": "Deploying dependency {{.output}} ...",
+    "translation": "Deploying dependency {{.output}} ..."
+  },
+  {
+    "id": "OK. Cancelling deployment.\n",
+    "translation": "OK. Cancelling deployment.\n"
+  },
+  {
+    "id": "OK. Canceling undeployment.\n",
+    "translation": "OK. Canceling undeployment.\n"
+  },
+  {
+    "id": "Undeployment did not complete sucessfully.\n",
+    "translation": "Undeployment did not complete sucessfully.\n"
+  },
+  {
+    "id": "Deployment removed successfully.\n",
+    "translation": "Deployment removed successfully.\n"
+  },
+  {
+    "id": "Undeployment did not complete sucessfully.\n",
+    "translation": "Undeployment did not complete sucessfully.\n"
+  },
+  {
+    "id": "Undeploying dependency {{.depName}} ...",
+    "translation": "Undeploying dependency {{.depName}} ..."
+  },
+  {
+    "id": "Undeployment of dependency {{.depName}} did not complete sucessfully.\n",
+    "translation": "Undeployment of dependency {{.depName}} did not complete sucessfully.\n"
+  },
+  {
+    "id": "Got error deleting action with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error deleting action with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error deleting rule with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error deleting rule with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error setting the status of rule with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error setting the status of rule with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error deleting trigger with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error deleting trigger with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error deleting trigger feed with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error deleting trigger feed with error message: {{.err}} and error code: {{.code}}.\n"
+  },
+  {
+    "id": "Got error deleting package with error message: {{.err}} and error code: {{.code}}.\n",
+    "translation": "Got error deleting package with error message: {{.err}} and error code: {{.code}}.\n"
   }
+
+
 ]

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

Mime
View raw message