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