You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openwhisk.apache.org by mr...@apache.org on 2017/09/07 15:02:15 UTC
[incubator-openwhisk-wskdeploy] branch master updated: Create the
error type for openwhisk client error (#447)
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 <sh...@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" <co...@openwhisk.apache.org>'].