You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openwhisk.apache.org by cs...@apache.org on 2018/01/28 14:59:12 UTC
[incubator-openwhisk-client-go] branch master updated (a086445 ->
6ab08ed)
This is an automated email from the ASF dual-hosted git repository.
csantanapr pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-openwhisk-client-go.git.
from a086445 Add path param support (#56)
new 6a2b07a Go format source code
new 6ab08ed Format source code
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.travis.yml | 3 +
whisk/action.go | 470 +++++++--------
whisk/activation.go | 296 ++++-----
whisk/api.go | 780 ++++++++++++------------
whisk/client.go | 1258 +++++++++++++++++++-------------------
whisk/client_test.go | 126 ++--
whisk/info.go | 80 +--
whisk/namespace.go | 92 +--
whisk/package.go | 319 +++++-----
whisk/rule.go | 312 +++++-----
whisk/sdk.go | 84 +--
whisk/shared.go | 62 +-
whisk/trace.go | 77 +--
whisk/trigger.go | 320 +++++-----
whisk/util.go | 118 ++--
whisk/wskerror.go | 214 +++----
whisk/wskprops.go | 474 +++++++--------
whisk/wskprops_test.go | 1471 ++++++++++++++++++++++-----------------------
wski18n/detection.go | 24 +-
wski18n/i18n.go | 152 ++---
wski18n/i18n_resources.go | 510 ++++++++--------
21 files changed, 3628 insertions(+), 3614 deletions(-)
--
To stop receiving notification emails like this one, please contact
csantanapr@apache.org.
[incubator-openwhisk-client-go] 01/02: Go format source code
Posted by cs...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
csantanapr pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-openwhisk-client-go.git
commit 6a2b07a83a8be9e4929cab5eea105e1c9caac1ec
Author: dubeejw <jw...@us.ibm.com>
AuthorDate: Sun Jan 28 01:58:11 2018 -0500
Go format source code
---
.travis.yml | 3 +++
1 file changed, 3 insertions(+)
diff --git a/.travis.yml b/.travis.yml
index 71fc279..bfe2777 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,6 +14,9 @@ git:
depth: 3
before_install:
+ - cd $TRAVIS_BUILD_DIR
+ - GO_FILES=$(find . -iname '*.go' -type f | grep -v /vendor/)
+ - test -z "$(gofmt -s -l $(echo $GO_FILES))"
- pip install --upgrade pip setuptools
- ./tools/travis/setup.sh
--
To stop receiving notification emails like this one, please contact
csantanapr@apache.org.
[incubator-openwhisk-client-go] 02/02: Format source code
Posted by cs...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
csantanapr pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-openwhisk-client-go.git
commit 6ab08ed6a8e2c2864426a4371935de4c1ab6fcd6
Author: dubeejw <jw...@us.ibm.com>
AuthorDate: Sun Jan 28 02:00:31 2018 -0500
Format source code
---
whisk/action.go | 470 +++++++--------
whisk/activation.go | 296 ++++-----
whisk/api.go | 780 ++++++++++++------------
whisk/client.go | 1258 +++++++++++++++++++-------------------
whisk/client_test.go | 126 ++--
whisk/info.go | 80 +--
whisk/namespace.go | 92 +--
whisk/package.go | 319 +++++-----
whisk/rule.go | 312 +++++-----
whisk/sdk.go | 84 +--
whisk/shared.go | 62 +-
whisk/trace.go | 77 +--
whisk/trigger.go | 320 +++++-----
whisk/util.go | 118 ++--
whisk/wskerror.go | 214 +++----
whisk/wskprops.go | 474 +++++++--------
whisk/wskprops_test.go | 1471 ++++++++++++++++++++++-----------------------
wski18n/detection.go | 24 +-
wski18n/i18n.go | 152 ++---
wski18n/i18n_resources.go | 510 ++++++++--------
20 files changed, 3625 insertions(+), 3614 deletions(-)
diff --git a/whisk/action.go b/whisk/action.go
index a32a9dd..1bdb879 100644
--- a/whisk/action.go
+++ b/whisk/action.go
@@ -18,143 +18,143 @@
package whisk
import (
- "fmt"
- "net/http"
- "errors"
- "net/url"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
- "strings"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "net/http"
+ "net/url"
+ "strings"
)
type ActionService struct {
- client *Client
+ client *Client
}
type Action struct {
- Namespace string `json:"namespace,omitempty"`
- Name string `json:"name,omitempty"`
- Version string `json:"version,omitempty"`
- Exec *Exec `json:"exec,omitempty"`
- Annotations KeyValueArr `json:"annotations,omitempty"`
- Parameters KeyValueArr `json:"parameters,omitempty"`
- Limits *Limits `json:"limits,omitempty"`
- Error string `json:"error,omitempty"`
- Code int `json:"code,omitempty"`
- Publish *bool `json:"publish,omitempty"`
+ Namespace string `json:"namespace,omitempty"`
+ Name string `json:"name,omitempty"`
+ Version string `json:"version,omitempty"`
+ Exec *Exec `json:"exec,omitempty"`
+ Annotations KeyValueArr `json:"annotations,omitempty"`
+ Parameters KeyValueArr `json:"parameters,omitempty"`
+ Limits *Limits `json:"limits,omitempty"`
+ Error string `json:"error,omitempty"`
+ Code int `json:"code,omitempty"`
+ Publish *bool `json:"publish,omitempty"`
}
type Exec struct {
- Kind string `json:"kind,omitempty"`
- Code *string `json:"code,omitempty"`
- Image string `json:"image,omitempty"`
- Init string `json:"init,omitempty"`
- Main string `json:"main,omitempty"`
- Components []string `json:"components,omitempty"` // List of fully qualified actions
- Binary *bool `json:"binary,omitempty"`
+ Kind string `json:"kind,omitempty"`
+ Code *string `json:"code,omitempty"`
+ Image string `json:"image,omitempty"`
+ Init string `json:"init,omitempty"`
+ Main string `json:"main,omitempty"`
+ Components []string `json:"components,omitempty"` // List of fully qualified actions
+ Binary *bool `json:"binary,omitempty"`
}
type ActionListOptions struct {
- Limit int `url:"limit"`
- Skip int `url:"skip"`
- Docs bool `url:"docs,omitempty"`
+ Limit int `url:"limit"`
+ Skip int `url:"skip"`
+ Docs bool `url:"docs,omitempty"`
}
// Compare(sortable) compares action to sortable for the purpose of sorting.
// REQUIRED: sortable must also be of type Action.
// ***Method of type Sortable***
-func(action Action) Compare(sortable Sortable) (bool) {
- // Sorts alphabetically by NAMESPACE -> PACKAGE_NAME -> ACTION_NAME, with
- // actions under default package at the top.
- var actionString string
- var compareString string
- actionToCompare := sortable.(Action)
-
- actionString = strings.ToLower(fmt.Sprintf("%s%s", action.Namespace, action.Name))
- compareString = strings.ToLower(fmt.Sprintf("%s%s", actionToCompare.Namespace,
- actionToCompare.Name))
- if strings.Contains(action.Namespace, "/") && !strings.Contains(actionToCompare.Namespace, "/") {
- return false
- } else if !strings.Contains(action.Namespace, "/") && strings.Contains(actionToCompare.Namespace, "/") {
- return true
- } else if strings.Contains(action.Namespace, "/") && strings.Contains(actionToCompare.Namespace, "/") {
- return actionString < compareString
- } else {
- return action.Name < actionToCompare.Name
- }
+func (action Action) Compare(sortable Sortable) bool {
+ // Sorts alphabetically by NAMESPACE -> PACKAGE_NAME -> ACTION_NAME, with
+ // actions under default package at the top.
+ var actionString string
+ var compareString string
+ actionToCompare := sortable.(Action)
+
+ actionString = strings.ToLower(fmt.Sprintf("%s%s", action.Namespace, action.Name))
+ compareString = strings.ToLower(fmt.Sprintf("%s%s", actionToCompare.Namespace,
+ actionToCompare.Name))
+ if strings.Contains(action.Namespace, "/") && !strings.Contains(actionToCompare.Namespace, "/") {
+ return false
+ } else if !strings.Contains(action.Namespace, "/") && strings.Contains(actionToCompare.Namespace, "/") {
+ return true
+ } else if strings.Contains(action.Namespace, "/") && strings.Contains(actionToCompare.Namespace, "/") {
+ return actionString < compareString
+ } else {
+ return action.Name < actionToCompare.Name
+ }
}
// ToHeaderString() returns the header for a list of actions
-func(action Action) ToHeaderString() string {
- return fmt.Sprintf("%s\n", "actions")
+func (action Action) ToHeaderString() string {
+ return fmt.Sprintf("%s\n", "actions")
}
// ToSummaryRowString() returns a compound string of required parameters for printing
// from CLI command `wsk action list`.
// ***Method of type Sortable***
-func(action Action) ToSummaryRowString() string{
- var kind string
- publishState := wski18n.T("private")
-
- for i := range action.Annotations {
- if (action.Annotations[i].Key == "exec") {
- kind = action.Annotations[i].Value.(string)
- break
- }
- }
- return fmt.Sprintf("%-70s %s %s\n", fmt.Sprintf("/%s/%s", action.Namespace, action.Name), publishState, kind)
+func (action Action) ToSummaryRowString() string {
+ var kind string
+ publishState := wski18n.T("private")
+
+ for i := range action.Annotations {
+ if action.Annotations[i].Key == "exec" {
+ kind = action.Annotations[i].Value.(string)
+ break
+ }
+ }
+ return fmt.Sprintf("%-70s %s %s\n", fmt.Sprintf("/%s/%s", action.Namespace, action.Name), publishState, kind)
}
/*
Determines if an action is a web action by examining the action's annotations. A value of true is returned if the
action's annotations contains a "web-export" key and its associated value is a boolean value of "true". Otherwise, false
is returned.
- */
+*/
func (action Action) WebAction() (webExportValue bool) {
- webExport := action.Annotations.GetValue("web-export")
- webExportValue, _ = webExport.(bool)
+ webExport := action.Annotations.GetValue("web-export")
+ webExportValue, _ = webExport.(bool)
- Debug(DbgInfo, "Web export value is '%t'\n", webExportValue)
+ Debug(DbgInfo, "Web export value is '%t'\n", webExportValue)
- return webExportValue
+ return webExportValue
}
/*
Returns the URL of an action as a string. A valid API host, path and version must be passed. A package that contains the
action must be passed as well. An empty string must be passed if the action is not packaged.
- */
+*/
func (action Action) ActionURL(apiHost string, apiPath string, apiVersion string, pkg string) (string, error) {
- baseURL, err := GetURLBase(apiHost, apiPath)
- if err != nil {
- Debug(DbgError, "GetURLBase(%s, %s) failed: %s\n", apiHost, apiPath, err)
- return "", err
- }
- webActionPath := "%s/%s/web/%s/%s/%s"
- actionPath := "%s/%s/namespaces/%s/actions/%s"
- packagedActionPath := actionPath + "/%s"
- namespace := strings.Split(action.Namespace, "/")[0]
- namespace = strings.Replace(url.QueryEscape(namespace), "+", "%20", -1)
- name := strings.Replace(url.QueryEscape(action.Name), "+", "%20", -1)
- pkg = strings.Replace(url.QueryEscape(pkg), "+", "%20", -1)
-
- var actionURL string
- if action.WebAction() {
- if len(pkg) == 0 {
- pkg = "default"
- }
-
- actionURL = fmt.Sprintf(webActionPath, baseURL, apiVersion, namespace, pkg, name)
- Debug(DbgInfo, "Web action URL: %s\n", actionURL)
- } else {
- if len(pkg) == 0 {
- actionURL = fmt.Sprintf(actionPath, baseURL, apiVersion, namespace, name)
- Debug(DbgInfo, "Packaged action URL: %s\n", actionURL)
- } else {
- actionURL = fmt.Sprintf(packagedActionPath, baseURL, apiVersion, namespace, pkg, name)
- Debug(DbgInfo, "Action URL: %s\n", actionURL)
- }
- }
-
- return actionURL, nil
+ baseURL, err := GetURLBase(apiHost, apiPath)
+ if err != nil {
+ Debug(DbgError, "GetURLBase(%s, %s) failed: %s\n", apiHost, apiPath, err)
+ return "", err
+ }
+ webActionPath := "%s/%s/web/%s/%s/%s"
+ actionPath := "%s/%s/namespaces/%s/actions/%s"
+ packagedActionPath := actionPath + "/%s"
+ namespace := strings.Split(action.Namespace, "/")[0]
+ namespace = strings.Replace(url.QueryEscape(namespace), "+", "%20", -1)
+ name := strings.Replace(url.QueryEscape(action.Name), "+", "%20", -1)
+ pkg = strings.Replace(url.QueryEscape(pkg), "+", "%20", -1)
+
+ var actionURL string
+ if action.WebAction() {
+ if len(pkg) == 0 {
+ pkg = "default"
+ }
+
+ actionURL = fmt.Sprintf(webActionPath, baseURL, apiVersion, namespace, pkg, name)
+ Debug(DbgInfo, "Web action URL: %s\n", actionURL)
+ } else {
+ if len(pkg) == 0 {
+ actionURL = fmt.Sprintf(actionPath, baseURL, apiVersion, namespace, name)
+ Debug(DbgInfo, "Packaged action URL: %s\n", actionURL)
+ } else {
+ actionURL = fmt.Sprintf(packagedActionPath, baseURL, apiVersion, namespace, pkg, name)
+ Debug(DbgInfo, "Action URL: %s\n", actionURL)
+ }
+ }
+
+ return actionURL, nil
}
////////////////////
@@ -162,153 +162,153 @@ func (action Action) ActionURL(apiHost string, apiPath string, apiVersion string
////////////////////
func (s *ActionService) List(packageName string, options *ActionListOptions) ([]Action, *http.Response, error) {
- var route string
- var actions []Action
-
- if (len(packageName) > 0) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- packageName = (&url.URL{Path: packageName}).String()
- route = fmt.Sprintf("actions/%s/", packageName)
- } else {
- route = fmt.Sprintf("actions")
- }
-
- routeUrl, err := addRouteOptions(route, options)
- if err != nil {
- Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
- errMsg := wski18n.T("Unable to add route options '{{.options}}'",
- map[string]interface{}{"options": options})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
- Debug(DbgError, "Action list route with options: %s\n", route)
-
- req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired) error: '%s'\n", routeUrl, err)
- errMsg := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": routeUrl, "err": err})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
-
- resp, err := s.client.Do(req, &actions, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return actions, resp, err
+ var route string
+ var actions []Action
+
+ if len(packageName) > 0 {
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ packageName = (&url.URL{Path: packageName}).String()
+ route = fmt.Sprintf("actions/%s/", packageName)
+ } else {
+ route = fmt.Sprintf("actions")
+ }
+
+ routeUrl, err := addRouteOptions(route, options)
+ if err != nil {
+ Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
+ errMsg := wski18n.T("Unable to add route options '{{.options}}'",
+ map[string]interface{}{"options": options})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+ Debug(DbgError, "Action list route with options: %s\n", route)
+
+ req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired) error: '%s'\n", routeUrl, err)
+ errMsg := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": routeUrl, "err": err})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+
+ resp, err := s.client.Do(req, &actions, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return actions, resp, err
}
func (s *ActionService) Insert(action *Action, overwrite bool) (*Action, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- actionName := (&url.URL{Path: action.Name}).String()
- route := fmt.Sprintf("actions/%s?overwrite=%t", actionName, overwrite)
- Debug(DbgInfo, "Action insert route: %s\n", route)
-
- req, err := s.client.NewRequest("PUT", route, action, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(PUT, %s, %#v) error: '%s'\n", route, err, action)
- errMsg := wski18n.T("Unable to create HTTP request for PUT '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
-
- a := new(Action)
- resp, err := s.client.Do(req, &a, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return a, resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ actionName := (&url.URL{Path: action.Name}).String()
+ route := fmt.Sprintf("actions/%s?overwrite=%t", actionName, overwrite)
+ Debug(DbgInfo, "Action insert route: %s\n", route)
+
+ req, err := s.client.NewRequest("PUT", route, action, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(PUT, %s, %#v) error: '%s'\n", route, err, action)
+ errMsg := wski18n.T("Unable to create HTTP request for PUT '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+
+ a := new(Action)
+ resp, err := s.client.Do(req, &a, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return a, resp, nil
}
func (s *ActionService) Get(actionName string) (*Action, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- actionName = (&url.URL{Path: actionName}).String()
- route := fmt.Sprintf("actions/%s", actionName)
-
- req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(GET, %s, nil) error: '%s'\n", route, err)
- errMsg := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
-
- a := new(Action)
- resp, err := s.client.Do(req, &a, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return a, resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ actionName = (&url.URL{Path: actionName}).String()
+ route := fmt.Sprintf("actions/%s", actionName)
+
+ req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(GET, %s, nil) error: '%s'\n", route, err)
+ errMsg := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+
+ a := new(Action)
+ resp, err := s.client.Do(req, &a, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return a, resp, nil
}
func (s *ActionService) Delete(actionName string) (*http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- actionName = (&url.URL{Path: actionName}).String()
- route := fmt.Sprintf("actions/%s", actionName)
- Debug(DbgInfo, "HTTP route: %s\n", route)
-
- req, err := s.client.NewRequest("DELETE", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(DELETE, %s, nil) error: '%s'\n", route, err)
- errMsg := wski18n.T("Unable to create HTTP request for DELETE '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, whiskErr
- }
-
- a := new(Action)
- resp, err := s.client.Do(req, a, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return resp, err
- }
-
- return resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ actionName = (&url.URL{Path: actionName}).String()
+ route := fmt.Sprintf("actions/%s", actionName)
+ Debug(DbgInfo, "HTTP route: %s\n", route)
+
+ req, err := s.client.NewRequest("DELETE", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(DELETE, %s, nil) error: '%s'\n", route, err)
+ errMsg := wski18n.T("Unable to create HTTP request for DELETE '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, whiskErr
+ }
+
+ a := new(Action)
+ resp, err := s.client.Do(req, a, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return resp, err
+ }
+
+ return resp, nil
}
-func (s *ActionService) Invoke(actionName string, payload interface{}, blocking bool, result bool) (map[string]interface {}, *http.Response, error) {
- var res map[string]interface {}
-
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- actionName = (&url.URL{Path: actionName}).String()
- route := fmt.Sprintf("actions/%s?blocking=%t&result=%t", actionName, blocking, result)
- Debug(DbgInfo, "HTTP route: %s\n", route)
-
- req, err := s.client.NewRequest("POST", route, payload, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(POST, %s, %#v) error: '%s'\n", route, payload, err)
- errMsg := wski18n.T("Unable to create HTTP request for POST '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
-
- resp, err := s.client.Do(req, &res, blocking)
-
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return res, resp, err
- }
-
- return res, resp, nil
+func (s *ActionService) Invoke(actionName string, payload interface{}, blocking bool, result bool) (map[string]interface{}, *http.Response, error) {
+ var res map[string]interface{}
+
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ actionName = (&url.URL{Path: actionName}).String()
+ route := fmt.Sprintf("actions/%s?blocking=%t&result=%t", actionName, blocking, result)
+ Debug(DbgInfo, "HTTP route: %s\n", route)
+
+ req, err := s.client.NewRequest("POST", route, payload, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(POST, %s, %#v) error: '%s'\n", route, payload, err)
+ errMsg := wski18n.T("Unable to create HTTP request for POST '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+
+ resp, err := s.client.Do(req, &res, blocking)
+
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return res, resp, err
+ }
+
+ return res, resp, nil
}
diff --git a/whisk/activation.go b/whisk/activation.go
index 62d472f..ccc97c9 100644
--- a/whisk/activation.go
+++ b/whisk/activation.go
@@ -18,198 +18,198 @@
package whisk
import (
- "fmt"
- "net/http"
- "errors"
- "net/url"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "net/http"
+ "net/url"
)
type ActivationService struct {
- client *Client
+ client *Client
}
type Activation struct {
- Namespace string `json:"namespace"`
- Name string `json:"name"`
- Version string `json:"version"`
- Subject string `json:"subject"`
- ActivationID string `json:"activationId"`
- Cause string `json:"cause,omitempty"`
- Start int64 `json:"start"` // When action started (in milliseconds since January 1, 1970 UTC)
- End int64 `json:"end"` // Since a 0 is a valid value from server, don't omit
- Duration int64 `json:"duration"` // Only available for actions
- Response `json:"response"`
- Logs []string `json:"logs"`
- Annotations KeyValueArr `json:"annotations"`
- Publish *bool `json:"publish,omitempty"`
+ Namespace string `json:"namespace"`
+ Name string `json:"name"`
+ Version string `json:"version"`
+ Subject string `json:"subject"`
+ ActivationID string `json:"activationId"`
+ Cause string `json:"cause,omitempty"`
+ Start int64 `json:"start"` // When action started (in milliseconds since January 1, 1970 UTC)
+ End int64 `json:"end"` // Since a 0 is a valid value from server, don't omit
+ Duration int64 `json:"duration"` // Only available for actions
+ Response `json:"response"`
+ Logs []string `json:"logs"`
+ Annotations KeyValueArr `json:"annotations"`
+ Publish *bool `json:"publish,omitempty"`
}
type Response struct {
- Status string `json:"status"`
- StatusCode int `json:"statusCode"`
- Success bool `json:"success"`
- Result *Result `json:"result,omitempty"`
+ Status string `json:"status"`
+ StatusCode int `json:"statusCode"`
+ Success bool `json:"success"`
+ Result *Result `json:"result,omitempty"`
}
type Result map[string]interface{}
type ActivationListOptions struct {
- Name string `url:"name,omitempty"`
- Limit int `url:"limit"`
- Skip int `url:"skip"`
- Since int64 `url:"since,omitempty"`
- Upto int64 `url:"upto,omitempty"`
- Docs bool `url:"docs,omitempty"`
+ Name string `url:"name,omitempty"`
+ Limit int `url:"limit"`
+ Skip int `url:"skip"`
+ Since int64 `url:"since,omitempty"`
+ Upto int64 `url:"upto,omitempty"`
+ Docs bool `url:"docs,omitempty"`
}
//MWD - This structure may no longer be needed as the log format is now a string and not JSON
type Log struct {
- Log string `json:"log,omitempty"`
- Stream string `json:"stream,omitempty"`
- Time string `json:"time,omitempty"`
+ Log string `json:"log,omitempty"`
+ Stream string `json:"stream,omitempty"`
+ Time string `json:"time,omitempty"`
}
// Compare(sortable) compares activation to sortable for the purpose of sorting.
// REQUIRED: sortable must also be of type Activation.
// ***Method of type Sortable***
// ***Currently, no method of sorting defined***
-func(activation Activation) Compare(sortable Sortable) (bool) {
- return true
+func (activation Activation) Compare(sortable Sortable) bool {
+ return true
}
// ToHeaderString() returns the header for a list of activations
-func(activation Activation) ToHeaderString() string {
- return fmt.Sprintf("%s\n", "activations")
+func (activation Activation) ToHeaderString() string {
+ return fmt.Sprintf("%s\n", "activations")
}
// ToSummaryRowString() returns a compound string of required parameters for printing
// from CLI command `wsk activation list`.
// ***Method of type Sortable***
-func(activation Activation) ToSummaryRowString() string {
- return fmt.Sprintf("%s %-20s\n", activation.ActivationID, activation.Name)
+func (activation Activation) ToSummaryRowString() string {
+ return fmt.Sprintf("%s %-20s\n", activation.ActivationID, activation.Name)
}
func (s *ActivationService) List(options *ActivationListOptions) ([]Activation, *http.Response, error) {
- // TODO :: for some reason /activations only works with "_" as namespace
- s.client.Namespace = "_"
- route := "activations"
- routeUrl, err := addRouteOptions(route, options)
- if err != nil {
- Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
- errStr := wski18n.T("Unable to append options '{{.options}}' to URL route '{{.route}}': {{.err}}",
- map[string]interface{}{"options": fmt.Sprintf("%#v", options), "route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired) error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- Debug(DbgInfo, "Sending HTTP request - URL '%s'; req %#v\n", req.URL.String(), req)
-
- var activations []Activation
- resp, err := s.client.Do(req, &activations, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return activations, resp, nil
+ // TODO :: for some reason /activations only works with "_" as namespace
+ s.client.Namespace = "_"
+ route := "activations"
+ routeUrl, err := addRouteOptions(route, options)
+ if err != nil {
+ Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
+ errStr := wski18n.T("Unable to append options '{{.options}}' to URL route '{{.route}}': {{.err}}",
+ map[string]interface{}{"options": fmt.Sprintf("%#v", options), "route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired) error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ Debug(DbgInfo, "Sending HTTP request - URL '%s'; req %#v\n", req.URL.String(), req)
+
+ var activations []Activation
+ resp, err := s.client.Do(req, &activations, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return activations, resp, nil
}
func (s *ActivationService) Get(activationID string) (*Activation, *http.Response, error) {
- // TODO :: for some reason /activations/:id only works with "_" as namespace
- s.client.Namespace = "_"
-
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- activationID = (&url.URL{Path: activationID}).String()
- route := fmt.Sprintf("activations/%s", activationID)
-
- req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(GET, %s) error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- Debug(DbgInfo, "Sending HTTP request - URL '%s'; req %#v\n", req.URL.String(), req)
-
- a := new(Activation)
- resp, err := s.client.Do(req, &a, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return a, resp, nil
+ // TODO :: for some reason /activations/:id only works with "_" as namespace
+ s.client.Namespace = "_"
+
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ activationID = (&url.URL{Path: activationID}).String()
+ route := fmt.Sprintf("activations/%s", activationID)
+
+ req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(GET, %s) error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ Debug(DbgInfo, "Sending HTTP request - URL '%s'; req %#v\n", req.URL.String(), req)
+
+ a := new(Activation)
+ resp, err := s.client.Do(req, &a, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return a, resp, nil
}
func (s *ActivationService) Logs(activationID string) (*Activation, *http.Response, error) {
- // TODO :: for some reason /activations/:id/logs only works with "_" as namespace
- s.client.Namespace = "_"
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- activationID = (&url.URL{Path: activationID}).String()
- route := fmt.Sprintf("activations/%s/logs", activationID)
-
- req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(GET, %s) error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- Debug(DbgInfo, "Sending HTTP request - URL '%s'; req %#v\n", req.URL.String(), req)
-
- activation := new(Activation)
- resp, err := s.client.Do(req, &activation, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return activation, resp, nil
+ // TODO :: for some reason /activations/:id/logs only works with "_" as namespace
+ s.client.Namespace = "_"
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ activationID = (&url.URL{Path: activationID}).String()
+ route := fmt.Sprintf("activations/%s/logs", activationID)
+
+ req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(GET, %s) error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ Debug(DbgInfo, "Sending HTTP request - URL '%s'; req %#v\n", req.URL.String(), req)
+
+ activation := new(Activation)
+ resp, err := s.client.Do(req, &activation, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return activation, resp, nil
}
func (s *ActivationService) Result(activationID string) (*Response, *http.Response, error) {
- // TODO :: for some reason /activations only works with "_" as namespace
- s.client.Namespace = "_"
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- activationID = (&url.URL{Path: activationID}).String()
- route := fmt.Sprintf("activations/%s/result", activationID)
-
- req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(GET, %s) error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- Debug(DbgInfo, "Sending HTTP request - URL '%s'; req %#v\n", req.URL.String(), req)
-
- r := new(Response)
- resp, err := s.client.Do(req, &r, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return r, resp, nil
+ // TODO :: for some reason /activations only works with "_" as namespace
+ s.client.Namespace = "_"
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ activationID = (&url.URL{Path: activationID}).String()
+ route := fmt.Sprintf("activations/%s/result", activationID)
+
+ req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(GET, %s) error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ Debug(DbgInfo, "Sending HTTP request - URL '%s'; req %#v\n", req.URL.String(), req)
+
+ r := new(Response)
+ resp, err := s.client.Do(req, &r, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return r, resp, nil
}
diff --git a/whisk/api.go b/whisk/api.go
index e62f2dc..64af10b 100644
--- a/whisk/api.go
+++ b/whisk/api.go
@@ -18,20 +18,20 @@
package whisk
import (
- "net/http"
- "errors"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
- "strings"
- "fmt"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "net/http"
+ "strings"
)
type ApiService struct {
- client *Client
+ client *Client
}
// wsk api create : Request, Response
type ApiCreateRequest struct {
- ApiDoc *Api `json:"apidoc,omitempty"`
+ ApiDoc *Api `json:"apidoc,omitempty"`
}
type ApiCreateRequestOptions ApiOptions
type ApiCreateResponse RetApi
@@ -40,210 +40,209 @@ type ApiCreateResponse RetApi
type ApiListRequest struct {
}
type ApiListRequestOptions struct {
- ApiOptions
- Limit int `url:"limit"`
- Skip int `url:"skip"`
- Docs bool `url:"docs,omitempty"`
+ ApiOptions
+ Limit int `url:"limit"`
+ Skip int `url:"skip"`
+ Docs bool `url:"docs,omitempty"`
}
type ApiListResponse RetApiArray
// wsk api get : Request, Response
type ApiGetRequest struct {
- Api
+ Api
}
type ApiGetRequestOptions ApiOptions
type ApiGetResponse RetApiArray
// wsk api delete : Request, Response
type ApiDeleteRequest struct {
- Api
+ Api
}
type ApiDeleteRequestOptions ApiOptions
-type ApiDeleteResponse struct {}
+type ApiDeleteResponse struct{}
type Api struct {
- Namespace string `json:"namespace,omitempty"`
- ApiName string `json:"apiName,omitempty"`
- GatewayBasePath string `json:"gatewayBasePath,omitempty"`
- GatewayRelPath string `json:"gatewayPath,omitempty"`
- GatewayMethod string `json:"gatewayMethod,omitempty"`
- Id string `json:"id,omitempty"`
- GatewayFullPath string `json:"gatewayFullPath,omitempty"`
- Swagger string `json:"swagger,omitempty"`
- Action *ApiAction `json:"action,omitempty"`
- PathParameters []ApiParameter `json:"pathParameters,omitempty"`
+ Namespace string `json:"namespace,omitempty"`
+ ApiName string `json:"apiName,omitempty"`
+ GatewayBasePath string `json:"gatewayBasePath,omitempty"`
+ GatewayRelPath string `json:"gatewayPath,omitempty"`
+ GatewayMethod string `json:"gatewayMethod,omitempty"`
+ Id string `json:"id,omitempty"`
+ GatewayFullPath string `json:"gatewayFullPath,omitempty"`
+ Swagger string `json:"swagger,omitempty"`
+ Action *ApiAction `json:"action,omitempty"`
+ PathParameters []ApiParameter `json:"pathParameters,omitempty"`
}
type ApiParameter struct {
- Name string `json:"name"`
- In string `json:"in"`
- Description string `json:"description,omitempty"`
- Required bool `json:"required,omitempty"`
- Type string `json:"type,omitempty"`
- Format string `json:"format,omitempty"`
- AllowEmptyValue bool `json:"allowEmptyValue,omitempty"`
- Items map[string]interface{} `json:"items,omitempty"`
- CollectionFormat string `json:"collectionFormat,omitempty"`
- Default interface{} `json:"default,omitempty"`
- Maximum int `json:"maximum,omitempty"`
- ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"`
- Minimum int `json:"minimum,omitempty"`
- ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty"`
- MaxLength int `json:"maxLength,omitempty"`
- MinLength int `json:"minLength,omitempty"`
- Pattern string `json:"pattern,omitempty"`
- MaxItems int `json:"maxItems,omitempty"`
- MinItems int `json:"minItems,omitempty"`
- UniqueItems bool `json:"uniqueItems,omitempty"`
- MultipleOf int `json:"multipleOf,omitempty"`
- Enum interface{} `json:"enum,omitempty"`
- Ref string `json:"$ref,omitempty"`
+ Name string `json:"name"`
+ In string `json:"in"`
+ Description string `json:"description,omitempty"`
+ Required bool `json:"required,omitempty"`
+ Type string `json:"type,omitempty"`
+ Format string `json:"format,omitempty"`
+ AllowEmptyValue bool `json:"allowEmptyValue,omitempty"`
+ Items map[string]interface{} `json:"items,omitempty"`
+ CollectionFormat string `json:"collectionFormat,omitempty"`
+ Default interface{} `json:"default,omitempty"`
+ Maximum int `json:"maximum,omitempty"`
+ ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"`
+ Minimum int `json:"minimum,omitempty"`
+ ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty"`
+ MaxLength int `json:"maxLength,omitempty"`
+ MinLength int `json:"minLength,omitempty"`
+ Pattern string `json:"pattern,omitempty"`
+ MaxItems int `json:"maxItems,omitempty"`
+ MinItems int `json:"minItems,omitempty"`
+ UniqueItems bool `json:"uniqueItems,omitempty"`
+ MultipleOf int `json:"multipleOf,omitempty"`
+ Enum interface{} `json:"enum,omitempty"`
+ Ref string `json:"$ref,omitempty"`
}
type ApiAction struct {
- Name string `json:"name,omitempty"`
- Namespace string `json:"namespace,omitempty"`
- BackendMethod string `json:"backendMethod,omitempty"`
- BackendUrl string `json:"backendUrl,omitempty"`
- Auth string `json:"authkey,omitempty"`
+ Name string `json:"name,omitempty"`
+ Namespace string `json:"namespace,omitempty"`
+ BackendMethod string `json:"backendMethod,omitempty"`
+ BackendUrl string `json:"backendUrl,omitempty"`
+ Auth string `json:"authkey,omitempty"`
}
type ApiOptions struct {
- ActionName string `url:"action,omitempty"`
- ApiBasePath string `url:"basepath,omitempty"`
- ApiRelPath string `url:"relpath,omitempty"`
- ApiVerb string `url:"operation,omitempty"`
- ApiName string `url:"apiname,omitempty"`
- SpaceGuid string `url:"spaceguid,omitempty"`
- AccessToken string `url:"accesstoken,omitempty"`
- ResponseType string `url:"responsetype,omitempty"`
+ ActionName string `url:"action,omitempty"`
+ ApiBasePath string `url:"basepath,omitempty"`
+ ApiRelPath string `url:"relpath,omitempty"`
+ ApiVerb string `url:"operation,omitempty"`
+ ApiName string `url:"apiname,omitempty"`
+ SpaceGuid string `url:"spaceguid,omitempty"`
+ AccessToken string `url:"accesstoken,omitempty"`
+ ResponseType string `url:"responsetype,omitempty"`
}
type ApiUserAuth struct {
- SpaceGuid string `json:"spaceguid,omitempty"`
- AccessToken string `json:"accesstoken,omitempty"`
+ SpaceGuid string `json:"spaceguid,omitempty"`
+ AccessToken string `json:"accesstoken,omitempty"`
}
type RetApiArray struct {
- Apis []ApiItem `json:"apis,omitempty"`
+ Apis []ApiItem `json:"apis,omitempty"`
}
type ApiItem struct {
- ApiId string `json:"id,omitempty"`
- QueryKey string `json:"key,omitempty"`
- ApiValue *RetApi `json:"value,omitempty"`
+ ApiId string `json:"id,omitempty"`
+ QueryKey string `json:"key,omitempty"`
+ ApiValue *RetApi `json:"value,omitempty"`
}
type RetApi struct {
- Namespace string `json:"namespace"`
- BaseUrl string `json:"gwApiUrl"`
- Activated bool `json:"gwApiActivated"`
- TenantId string `json:"tenantId"`
- Swagger *ApiSwagger `json:"apidoc,omitempty"`
+ Namespace string `json:"namespace"`
+ BaseUrl string `json:"gwApiUrl"`
+ Activated bool `json:"gwApiActivated"`
+ TenantId string `json:"tenantId"`
+ Swagger *ApiSwagger `json:"apidoc,omitempty"`
}
type ApiSwagger struct {
- SwaggerName string `json:"swagger,omitempty"`
- BasePath string `json:"basePath,omitempty"`
- Info *ApiSwaggerInfo `json:"info,omitempty"`
- Paths map[string]*ApiSwaggerPath `json:"paths,omitempty"`
- SecurityDef interface{} `json:"securityDefinitions,omitempty"`
- Security interface{} `json:"security,omitempty"`
- XConfig interface{} `json:"x-ibm-configuration,omitempty"`
- XRateLimit interface{} `json:"x-ibm-rate-limit,omitempty"`
-}
-
-type ApiSwaggerPath struct{
- Get *ApiSwaggerOperation `json:"get,omitempty"`
- Put *ApiSwaggerOperation `json:"put,omitempty"`
- Post *ApiSwaggerOperation `json:"post,omitempty"`
- Delete *ApiSwaggerOperation `json:"delete,omitempty"`
- Options *ApiSwaggerOperation `json:"options,omitempty"`
- Head *ApiSwaggerOperation `json:"head,omitempty"`
- Patch *ApiSwaggerOperation `json:"patch,omitempty"`
- Parameters []ApiParameter `json:"parameters,omitempty"`
+ SwaggerName string `json:"swagger,omitempty"`
+ BasePath string `json:"basePath,omitempty"`
+ Info *ApiSwaggerInfo `json:"info,omitempty"`
+ Paths map[string]*ApiSwaggerPath `json:"paths,omitempty"`
+ SecurityDef interface{} `json:"securityDefinitions,omitempty"`
+ Security interface{} `json:"security,omitempty"`
+ XConfig interface{} `json:"x-ibm-configuration,omitempty"`
+ XRateLimit interface{} `json:"x-ibm-rate-limit,omitempty"`
+}
+
+type ApiSwaggerPath struct {
+ Get *ApiSwaggerOperation `json:"get,omitempty"`
+ Put *ApiSwaggerOperation `json:"put,omitempty"`
+ Post *ApiSwaggerOperation `json:"post,omitempty"`
+ Delete *ApiSwaggerOperation `json:"delete,omitempty"`
+ Options *ApiSwaggerOperation `json:"options,omitempty"`
+ Head *ApiSwaggerOperation `json:"head,omitempty"`
+ Patch *ApiSwaggerOperation `json:"patch,omitempty"`
+ Parameters []ApiParameter `json:"parameters,omitempty"`
}
func (asp *ApiSwaggerPath) MakeOperationMap() map[string]*ApiSwaggerOperation {
- var opMap map[string]*ApiSwaggerOperation = make(map[string]*ApiSwaggerOperation)
- if asp.Get != nil {
- opMap["get"] = asp.Get
- }
- if asp.Put != nil {
- opMap["put"] = asp.Put
- }
- if asp.Post != nil {
- opMap["post"] = asp.Post
- }
- if asp.Delete != nil {
- opMap["delete"] = asp.Delete
- }
- if asp.Options != nil {
- opMap["options"] = asp.Options
- }
- if asp.Head != nil {
- opMap["head"] = asp.Head
- }
- if asp.Patch != nil {
- opMap["patch"] = asp.Patch
- }
- return opMap
+ var opMap map[string]*ApiSwaggerOperation = make(map[string]*ApiSwaggerOperation)
+ if asp.Get != nil {
+ opMap["get"] = asp.Get
+ }
+ if asp.Put != nil {
+ opMap["put"] = asp.Put
+ }
+ if asp.Post != nil {
+ opMap["post"] = asp.Post
+ }
+ if asp.Delete != nil {
+ opMap["delete"] = asp.Delete
+ }
+ if asp.Options != nil {
+ opMap["options"] = asp.Options
+ }
+ if asp.Head != nil {
+ opMap["head"] = asp.Head
+ }
+ if asp.Patch != nil {
+ opMap["patch"] = asp.Patch
+ }
+ return opMap
}
-
type ApiSwaggerInfo struct {
- Title string `json:"title,omitempty"`
- Version string `json:"version,omitempty"`
+ Title string `json:"title,omitempty"`
+ Version string `json:"version,omitempty"`
}
type ApiSwaggerOperation struct {
- OperationId string `json:"operationId"`
- Parameters []ApiParameter `json:"parameters,omitempty"`
- Responses interface{} `json:"responses"`
- XOpenWhisk *ApiSwaggerOpXOpenWhisk `json:"x-openwhisk,omitempty"`
+ OperationId string `json:"operationId"`
+ Parameters []ApiParameter `json:"parameters,omitempty"`
+ Responses interface{} `json:"responses"`
+ XOpenWhisk *ApiSwaggerOpXOpenWhisk `json:"x-openwhisk,omitempty"`
}
type ApiSwaggerOpXOpenWhisk struct {
- ActionName string `json:"action"`
- Namespace string `json:"namespace"`
- Package string `json:"package"`
- ApiUrl string `json:"url"`
+ ActionName string `json:"action"`
+ Namespace string `json:"namespace"`
+ Package string `json:"package"`
+ ApiUrl string `json:"url"`
}
// Used for printing individual APIs in non-truncated form
type ApiFilteredList struct {
- ActionName string
- ApiName string
- BasePath string
- RelPath string
- Verb string
- Url string
+ ActionName string
+ ApiName string
+ BasePath string
+ RelPath string
+ Verb string
+ Url string
}
// Used for printing individual APIs in truncated form
type ApiFilteredRow struct {
- ActionName string
- ApiName string
- BasePath string
- RelPath string
- Verb string
- Url string
- FmtString string
+ ActionName string
+ ApiName string
+ BasePath string
+ RelPath string
+ Verb string
+ Url string
+ FmtString string
}
-var ApiVerbs map[string]bool = map[string]bool {
- "GET": true,
- "PUT": true,
- "POST": true,
- "DELETE": true,
- "PATCH": true,
- "HEAD": true,
- "OPTIONS": true,
+var ApiVerbs map[string]bool = map[string]bool{
+ "GET": true,
+ "PUT": true,
+ "POST": true,
+ "DELETE": true,
+ "PATCH": true,
+ "HEAD": true,
+ "OPTIONS": true,
}
const (
- Overwrite = true
- DoNotOverwrite = false
+ Overwrite = true
+ DoNotOverwrite = false
)
/////////////////
@@ -253,297 +252,296 @@ const (
// Compare(sortable) compares api to sortable for the purpose of sorting.
// REQUIRED: sortable must also be of type ApiFilteredList.
// ***Method of type Sortable***
-func(api ApiFilteredList) Compare(sortable Sortable) (bool) {
- // Sorts alphabetically by [BASE_PATH | API_NAME] -> REL_PATH -> API_VERB
- apiToCompare := sortable.(ApiFilteredList)
- var apiString string
- var compareString string
+func (api ApiFilteredList) Compare(sortable Sortable) bool {
+ // Sorts alphabetically by [BASE_PATH | API_NAME] -> REL_PATH -> API_VERB
+ apiToCompare := sortable.(ApiFilteredList)
+ var apiString string
+ var compareString string
- apiString = strings.ToLower(fmt.Sprintf("%s%s%s",api.BasePath, api.RelPath,
- api.Verb))
- compareString = strings.ToLower(fmt.Sprintf("%s%s%s", apiToCompare.BasePath,
- apiToCompare.RelPath, apiToCompare.Verb))
+ apiString = strings.ToLower(fmt.Sprintf("%s%s%s", api.BasePath, api.RelPath,
+ api.Verb))
+ compareString = strings.ToLower(fmt.Sprintf("%s%s%s", apiToCompare.BasePath,
+ apiToCompare.RelPath, apiToCompare.Verb))
- return apiString < compareString
+ return apiString < compareString
}
// ToHeaderString() returns the header for a list of apis
-func(api ApiFilteredList) ToHeaderString() string {
- return ""
+func (api ApiFilteredList) ToHeaderString() string {
+ return ""
}
// ToSummaryRowString() returns a compound string of required parameters for printing
// from CLI command `wsk api list` or `wsk api-experimental list`.
// ***Method of type Sortable***
-func(api ApiFilteredList) ToSummaryRowString() string {
- return fmt.Sprintf("%s %s %s %s %s %s",
- fmt.Sprintf("%s: %s\n", wski18n.T("Action"), api.ActionName),
- fmt.Sprintf(" %s: %s\n", wski18n.T("API Name"), api.ApiName),
- fmt.Sprintf(" %s: %s\n", wski18n.T("Base path"), api.BasePath),
- fmt.Sprintf(" %s: %s\n", wski18n.T("Path"), api.RelPath),
- fmt.Sprintf(" %s: %s\n", wski18n.T("Verb"), api.Verb),
- fmt.Sprintf(" %s: %s\n", wski18n.T("URL"), api.Url))
+func (api ApiFilteredList) ToSummaryRowString() string {
+ return fmt.Sprintf("%s %s %s %s %s %s",
+ fmt.Sprintf("%s: %s\n", wski18n.T("Action"), api.ActionName),
+ fmt.Sprintf(" %s: %s\n", wski18n.T("API Name"), api.ApiName),
+ fmt.Sprintf(" %s: %s\n", wski18n.T("Base path"), api.BasePath),
+ fmt.Sprintf(" %s: %s\n", wski18n.T("Path"), api.RelPath),
+ fmt.Sprintf(" %s: %s\n", wski18n.T("Verb"), api.Verb),
+ fmt.Sprintf(" %s: %s\n", wski18n.T("URL"), api.Url))
}
// Compare(sortable) compares api to sortable for the purpose of sorting.
// REQUIRED: sortable must also be of type ApiFilteredRow.
// ***Method of type Sortable***
-func(api ApiFilteredRow) Compare(sortable Sortable) (bool) {
- // Sorts alphabetically by [BASE_PATH | API_NAME] -> REL_PATH -> API_VERB
- var apiString string
- var compareString string
- apiToCompare := sortable.(ApiFilteredRow)
+func (api ApiFilteredRow) Compare(sortable Sortable) bool {
+ // Sorts alphabetically by [BASE_PATH | API_NAME] -> REL_PATH -> API_VERB
+ var apiString string
+ var compareString string
+ apiToCompare := sortable.(ApiFilteredRow)
- apiString = strings.ToLower(fmt.Sprintf("%s%s%s",api.BasePath, api.RelPath,
- api.Verb))
- compareString = strings.ToLower(fmt.Sprintf("%s%s%s", apiToCompare.BasePath,
- apiToCompare.RelPath, apiToCompare.Verb))
+ apiString = strings.ToLower(fmt.Sprintf("%s%s%s", api.BasePath, api.RelPath,
+ api.Verb))
+ compareString = strings.ToLower(fmt.Sprintf("%s%s%s", apiToCompare.BasePath,
+ apiToCompare.RelPath, apiToCompare.Verb))
- return apiString < compareString
+ return apiString < compareString
}
// ToHeaderString() returns the header for a list of apis
-func(api ApiFilteredRow) ToHeaderString() string {
- return fmt.Sprintf("%s", fmt.Sprintf(api.FmtString, "Action", "Verb", "API Name", "URL"))
+func (api ApiFilteredRow) ToHeaderString() string {
+ return fmt.Sprintf("%s", fmt.Sprintf(api.FmtString, "Action", "Verb", "API Name", "URL"))
}
// ToSummaryRowString() returns a compound string of required parameters for printing
// from CLI command `wsk api list -f` or `wsk api-experimental list -f`.
// ***Method of type Sortable***
-func(api ApiFilteredRow) ToSummaryRowString() string {
- return fmt.Sprintf(api.FmtString, api.ActionName, api.Verb, api.ApiName, api.Url)
+func (api ApiFilteredRow) ToSummaryRowString() string {
+ return fmt.Sprintf(api.FmtString, api.ActionName, api.Verb, api.ApiName, api.Url)
}
func (s *ApiService) List(apiListOptions *ApiListRequestOptions) (*ApiListResponse, *http.Response, error) {
- route := "web/whisk.system/apimgmt/getApi.http"
-
- routeUrl, err := addRouteOptions(route, apiListOptions)
- if err != nil {
- Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, apiListOptions, err)
- errMsg := wski18n.T("Unable to add route options '{{.options}}'",
- map[string]interface{}{"options": apiListOptions})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
- Debug(DbgInfo, "Api GET/list route with api options: %s\n", routeUrl)
-
- req, err := s.client.NewRequestUrl("GET", routeUrl, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson) error: '%s'\n", routeUrl, err)
- errMsg := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": routeUrl, "err": err})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
-
- apiArray := new(ApiListResponse)
- resp, err := s.client.Do(req, &apiArray, ExitWithErrorOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- err = validateApiListResponse(apiArray)
- if err != nil {
- Debug(DbgError, "Not a valid ApiListReponse object\n")
- return nil, resp, err
- }
-
- return apiArray, resp, err
+ route := "web/whisk.system/apimgmt/getApi.http"
+
+ routeUrl, err := addRouteOptions(route, apiListOptions)
+ if err != nil {
+ Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, apiListOptions, err)
+ errMsg := wski18n.T("Unable to add route options '{{.options}}'",
+ map[string]interface{}{"options": apiListOptions})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+ Debug(DbgInfo, "Api GET/list route with api options: %s\n", routeUrl)
+
+ req, err := s.client.NewRequestUrl("GET", routeUrl, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson) error: '%s'\n", routeUrl, err)
+ errMsg := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": routeUrl, "err": err})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+
+ apiArray := new(ApiListResponse)
+ resp, err := s.client.Do(req, &apiArray, ExitWithErrorOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ err = validateApiListResponse(apiArray)
+ if err != nil {
+ Debug(DbgError, "Not a valid ApiListReponse object\n")
+ return nil, resp, err
+ }
+
+ return apiArray, resp, err
}
func (s *ApiService) Insert(api *ApiCreateRequest, options *ApiCreateRequestOptions, overwrite bool) (*ApiCreateResponse, *http.Response, error) {
- route := "web/whisk.system/apimgmt/createApi.http"
- Debug(DbgInfo, "Api PUT route: %s\n", route)
-
- routeUrl, err := addRouteOptions(route, options)
- if err != nil {
- Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
- errMsg := wski18n.T("Unable to add route options '{{.options}}'",
- map[string]interface{}{"options": options})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
- Debug(DbgError, "Api create route with options: %s\n", routeUrl)
-
- req, err := s.client.NewRequestUrl("POST", routeUrl, api, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(POST, %s, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson) error: '%s'\n", route, err)
- errMsg := wski18n.T("Unable to create HTTP request for POST '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
-
- retApi := new(ApiCreateResponse)
- resp, err := s.client.Do(req, &retApi, ExitWithErrorOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- err = validateApiSwaggerResponse(retApi.Swagger)
- if err != nil {
- Debug(DbgError, "Not a valid API creation response\n")
- return nil, resp, err
- }
-
- return retApi, resp, nil
+ route := "web/whisk.system/apimgmt/createApi.http"
+ Debug(DbgInfo, "Api PUT route: %s\n", route)
+
+ routeUrl, err := addRouteOptions(route, options)
+ if err != nil {
+ Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
+ errMsg := wski18n.T("Unable to add route options '{{.options}}'",
+ map[string]interface{}{"options": options})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+ Debug(DbgError, "Api create route with options: %s\n", routeUrl)
+
+ req, err := s.client.NewRequestUrl("POST", routeUrl, api, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(POST, %s, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson) error: '%s'\n", route, err)
+ errMsg := wski18n.T("Unable to create HTTP request for POST '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+
+ retApi := new(ApiCreateResponse)
+ resp, err := s.client.Do(req, &retApi, ExitWithErrorOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ err = validateApiSwaggerResponse(retApi.Swagger)
+ if err != nil {
+ Debug(DbgError, "Not a valid API creation response\n")
+ return nil, resp, err
+ }
+
+ return retApi, resp, nil
}
func (s *ApiService) Get(api *ApiGetRequest, options *ApiGetRequestOptions) (*ApiGetResponse, *http.Response, error) {
- route := "web/whisk.system/apimgmt/getApi.http"
- Debug(DbgInfo, "Api GET route: %s\n", route)
-
- routeUrl, err := addRouteOptions(route, options)
- if err != nil {
- Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
- errMsg := wski18n.T("Unable to add route options '{{.options}}'",
- map[string]interface{}{"options": options})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
- Debug(DbgError, "Api get route with options: %s\n", routeUrl)
-
- req, err := s.client.NewRequestUrl("GET", routeUrl, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson) error: '%s'\n", route, err)
- errMsg := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, nil, whiskErr
- }
-
- retApi := new(ApiGetResponse)
- resp, err := s.client.Do(req, &retApi, ExitWithErrorOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return retApi, resp, nil
+ route := "web/whisk.system/apimgmt/getApi.http"
+ Debug(DbgInfo, "Api GET route: %s\n", route)
+
+ routeUrl, err := addRouteOptions(route, options)
+ if err != nil {
+ Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
+ errMsg := wski18n.T("Unable to add route options '{{.options}}'",
+ map[string]interface{}{"options": options})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+ Debug(DbgError, "Api get route with options: %s\n", routeUrl)
+
+ req, err := s.client.NewRequestUrl("GET", routeUrl, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson) error: '%s'\n", route, err)
+ errMsg := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, nil, whiskErr
+ }
+
+ retApi := new(ApiGetResponse)
+ resp, err := s.client.Do(req, &retApi, ExitWithErrorOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return retApi, resp, nil
}
func (s *ApiService) Delete(api *ApiDeleteRequest, options *ApiDeleteRequestOptions) (*http.Response, error) {
- route := "web/whisk.system/apimgmt/deleteApi.http"
- Debug(DbgInfo, "Api DELETE route: %s\n", route)
-
- routeUrl, err := addRouteOptions(route, options)
- if err != nil {
- Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
- errMsg := wski18n.T("Unable to add route options '{{.options}}'",
- map[string]interface{}{"options": options})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, whiskErr
- }
- Debug(DbgError, "Api DELETE route with options: %s\n", routeUrl)
-
- req, err := s.client.NewRequestUrl("DELETE", routeUrl, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(DELETE, %s, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson) error: '%s'\n", route, err)
- errMsg := wski18n.T("Unable to create HTTP request for DELETE '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
- NO_DISPLAY_USAGE)
- return nil, whiskErr
- }
-
- retApi := new(ApiDeleteResponse)
- resp, err := s.client.Do(req, &retApi, ExitWithErrorOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return resp, err
- }
-
- return nil, nil
+ route := "web/whisk.system/apimgmt/deleteApi.http"
+ Debug(DbgInfo, "Api DELETE route: %s\n", route)
+
+ routeUrl, err := addRouteOptions(route, options)
+ if err != nil {
+ Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
+ errMsg := wski18n.T("Unable to add route options '{{.options}}'",
+ map[string]interface{}{"options": options})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, whiskErr
+ }
+ Debug(DbgError, "Api DELETE route with options: %s\n", routeUrl)
+
+ req, err := s.client.NewRequestUrl("DELETE", routeUrl, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(DELETE, %s, nil, DoNotIncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson) error: '%s'\n", route, err)
+ errMsg := wski18n.T("Unable to create HTTP request for DELETE '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ whiskErr := MakeWskErrorFromWskError(errors.New(errMsg), err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG,
+ NO_DISPLAY_USAGE)
+ return nil, whiskErr
+ }
+
+ retApi := new(ApiDeleteResponse)
+ resp, err := s.client.Do(req, &retApi, ExitWithErrorOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return resp, err
+ }
+
+ return nil, nil
}
-
func validateApiListResponse(apiList *ApiListResponse) error {
- for i := 0; i < len(apiList.Apis); i++ {
- if apiList.Apis[i].ApiValue == nil {
- Debug(DbgError, "validateApiResponse: No value stanza in api %v\n", apiList.Apis[i])
- errMsg := wski18n.T("Internal error. Missing value stanza in API configuration response")
- whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return whiskErr
- }
- err := validateApiSwaggerResponse(apiList.Apis[i].ApiValue.Swagger)
- if (err != nil) {
- Debug(DbgError, "validateApiListResponse: Invalid Api: %v\n", apiList.Apis[i])
- return err
- }
- }
- return nil
+ for i := 0; i < len(apiList.Apis); i++ {
+ if apiList.Apis[i].ApiValue == nil {
+ Debug(DbgError, "validateApiResponse: No value stanza in api %v\n", apiList.Apis[i])
+ errMsg := wski18n.T("Internal error. Missing value stanza in API configuration response")
+ whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ err := validateApiSwaggerResponse(apiList.Apis[i].ApiValue.Swagger)
+ if err != nil {
+ Debug(DbgError, "validateApiListResponse: Invalid Api: %v\n", apiList.Apis[i])
+ return err
+ }
+ }
+ return nil
}
func validateApiSwaggerResponse(swagger *ApiSwagger) error {
- if swagger == nil {
- Debug(DbgError, "validateApiSwaggerResponse: No apidoc stanza in api\n")
- errMsg := wski18n.T("Internal error. Missing apidoc stanza in API configuration")
- whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return whiskErr
- }
- for path, _ := range swagger.Paths {
- err := validateApiPath(swagger.Paths[path])
- if err != nil {
- Debug(DbgError, "validateApiResponse: Invalid Api Path object: %v\n", swagger.Paths[path])
- return err
- }
- }
-
- return nil
+ if swagger == nil {
+ Debug(DbgError, "validateApiSwaggerResponse: No apidoc stanza in api\n")
+ errMsg := wski18n.T("Internal error. Missing apidoc stanza in API configuration")
+ whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ for path := range swagger.Paths {
+ err := validateApiPath(swagger.Paths[path])
+ if err != nil {
+ Debug(DbgError, "validateApiResponse: Invalid Api Path object: %v\n", swagger.Paths[path])
+ return err
+ }
+ }
+
+ return nil
}
func validateApiPath(path *ApiSwaggerPath) error {
- for op, opv := range path.MakeOperationMap() {
- err := validateApiOperation(op, opv)
- if err != nil {
- Debug(DbgError, "validateApiPath: Invalid Api operation object: %v\n", opv)
- return err
- }
- }
- return nil
+ for op, opv := range path.MakeOperationMap() {
+ err := validateApiOperation(op, opv)
+ if err != nil {
+ Debug(DbgError, "validateApiPath: Invalid Api operation object: %v\n", opv)
+ return err
+ }
+ }
+ return nil
}
func validateApiOperation(opName string, op *ApiSwaggerOperation) error {
- if (op.XOpenWhisk != nil && len(op.OperationId) == 0) {
- Debug(DbgError, "validateApiOperation: No operationId field in operation %v\n", op)
- errMsg := wski18n.T("Missing operationId field in API configuration for operation {{.op}}",
- map[string]interface{}{"op": opName})
- whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return whiskErr
- }
-
- if (op.XOpenWhisk != nil && len(op.XOpenWhisk.Namespace) == 0) {
- Debug(DbgError, "validateApiOperation: no x-openwhisk.namespace stanza in operation %v\n", op)
- errMsg := wski18n.T("Missing x-openwhisk.namespace field in API configuration for operation {{.op}}",
- map[string]interface{}{"op": opName})
- whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return whiskErr
- }
-
- // Note: The op.XOpenWhisk.Package field can have a value of "", so don't enforce a value
-
- if (op.XOpenWhisk != nil && len(op.XOpenWhisk.ActionName) == 0) {
- Debug(DbgError, "validateApiOperation: no x-openwhisk.action stanza in operation %v\n", op)
- errMsg := wski18n.T("Missing x-openwhisk.action field in API configuration for operation {{.op}}",
- map[string]interface{}{"op": opName})
- whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return whiskErr
- }
- if (op.XOpenWhisk != nil && len(op.XOpenWhisk.ApiUrl) == 0) {
- Debug(DbgError, "validateApiOperation: no x-openwhisk.url stanza in operation %v\n", op)
- errMsg := wski18n.T("Missing x-openwhisk.url field in API configuration for operation {{.op}}",
- map[string]interface{}{"op": opName})
- whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return whiskErr
- }
- return nil
+ if op.XOpenWhisk != nil && len(op.OperationId) == 0 {
+ Debug(DbgError, "validateApiOperation: No operationId field in operation %v\n", op)
+ errMsg := wski18n.T("Missing operationId field in API configuration for operation {{.op}}",
+ map[string]interface{}{"op": opName})
+ whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ if op.XOpenWhisk != nil && len(op.XOpenWhisk.Namespace) == 0 {
+ Debug(DbgError, "validateApiOperation: no x-openwhisk.namespace stanza in operation %v\n", op)
+ errMsg := wski18n.T("Missing x-openwhisk.namespace field in API configuration for operation {{.op}}",
+ map[string]interface{}{"op": opName})
+ whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+
+ // Note: The op.XOpenWhisk.Package field can have a value of "", so don't enforce a value
+
+ if op.XOpenWhisk != nil && len(op.XOpenWhisk.ActionName) == 0 {
+ Debug(DbgError, "validateApiOperation: no x-openwhisk.action stanza in operation %v\n", op)
+ errMsg := wski18n.T("Missing x-openwhisk.action field in API configuration for operation {{.op}}",
+ map[string]interface{}{"op": opName})
+ whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ if op.XOpenWhisk != nil && len(op.XOpenWhisk.ApiUrl) == 0 {
+ Debug(DbgError, "validateApiOperation: no x-openwhisk.url stanza in operation %v\n", op)
+ errMsg := wski18n.T("Missing x-openwhisk.url field in API configuration for operation {{.op}}",
+ map[string]interface{}{"op": opName})
+ whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return whiskErr
+ }
+ return nil
}
diff --git a/whisk/client.go b/whisk/client.go
index b32af63..9734a0c 100644
--- a/whisk/client.go
+++ b/whisk/client.go
@@ -18,193 +18,193 @@
package whisk
import (
- "bytes"
- "encoding/base64"
- "encoding/json"
- "fmt"
- "io"
- "io/ioutil"
- "net/http"
- "net/url"
- "crypto/tls"
- "errors"
- "reflect"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
- "strings"
- "time"
- "regexp"
+ "bytes"
+ "crypto/tls"
+ "encoding/base64"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "reflect"
+ "regexp"
+ "strings"
+ "time"
)
const (
- AuthRequired = true
- NoAuth = false
- IncludeNamespaceInUrl = true
- DoNotIncludeNamespaceInUrl = false
- AppendOpenWhiskPathPrefix = true
- DoNotAppendOpenWhiskPathPrefix = false
- EncodeBodyAsJson = "json"
- EncodeBodyAsFormData = "formdata"
- ProcessTimeOut = true
- DoNotProcessTimeOut = false
- ExitWithErrorOnTimeout = true
- ExitWithSuccessOnTimeout = false
- DEFAULT_HTTP_TIMEOUT = 30
+ AuthRequired = true
+ NoAuth = false
+ IncludeNamespaceInUrl = true
+ DoNotIncludeNamespaceInUrl = false
+ AppendOpenWhiskPathPrefix = true
+ DoNotAppendOpenWhiskPathPrefix = false
+ EncodeBodyAsJson = "json"
+ EncodeBodyAsFormData = "formdata"
+ ProcessTimeOut = true
+ DoNotProcessTimeOut = false
+ ExitWithErrorOnTimeout = true
+ ExitWithSuccessOnTimeout = false
+ DEFAULT_HTTP_TIMEOUT = 30
)
type Client struct {
- client *http.Client
- *Config
- Transport *http.Transport
-
- Sdks *SdkService
- Triggers *TriggerService
- Actions *ActionService
- Rules *RuleService
- Activations *ActivationService
- Packages *PackageService
- Namespaces *NamespaceService
- Info *InfoService
- Apis *ApiService
+ client *http.Client
+ *Config
+ Transport *http.Transport
+
+ Sdks *SdkService
+ Triggers *TriggerService
+ Actions *ActionService
+ Rules *RuleService
+ Activations *ActivationService
+ Packages *PackageService
+ Namespaces *NamespaceService
+ Info *InfoService
+ Apis *ApiService
}
type Config struct {
- Namespace string // NOTE :: Default is "_"
- Cert string
- Key string
- AuthToken string
- Host string
- BaseURL *url.URL // NOTE :: Default is "openwhisk.ng.bluemix.net"
- Version string
- Verbose bool
- Debug bool // For detailed tracing
- Insecure bool
- UserAgent string
+ Namespace string // NOTE :: Default is "_"
+ Cert string
+ Key string
+ AuthToken string
+ Host string
+ BaseURL *url.URL // NOTE :: Default is "openwhisk.ng.bluemix.net"
+ Version string
+ Verbose bool
+ Debug bool // For detailed tracing
+ Insecure bool
+ UserAgent string
}
type ObfuscateSet struct {
- Regex string
- Replacement string
+ Regex string
+ Replacement string
}
var DefaultObfuscateArr = []ObfuscateSet{
- {
- Regex: "\"[Pp]assword\":\\s*\".*\"",
- Replacement: `"password": "******"`,
- },
+ {
+ Regex: "\"[Pp]assword\":\\s*\".*\"",
+ Replacement: `"password": "******"`,
+ },
}
func NewClient(httpClient *http.Client, config_input *Config) (*Client, error) {
- var config *Config
- if config_input == nil {
- defaultConfig, err := GetDefaultConfig()
- if err != nil {
- return nil ,err
- } else {
- config = defaultConfig
- }
- } else {
- config = config_input
- }
-
- if httpClient == nil {
- httpClient = &http.Client{
- Timeout: time.Second * DEFAULT_HTTP_TIMEOUT,
- }
- }
-
- var err error
- var errStr = ""
- if len(config.Host) == 0 {
- errStr = wski18n.T("Unable to create request URL, because OpenWhisk API host is missing")
- } else if config.BaseURL == nil {
- config.BaseURL, err = GetUrlBase(config.Host)
- if err != nil {
- Debug(DbgError, "Unable to create request URL, because the api host %s is invalid\n", config.Host, err)
- errStr = wski18n.T("Unable to create request URL, because the api host '{{.host}}' is invalid: {{.err}}",
- map[string]interface{}{"host": config.Host, "err": err})
- }
- }
-
- if len(errStr) != 0 {
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
-
- if len(config.Namespace) == 0 {
- config.Namespace = "_"
- }
-
- if len(config.Version) == 0 {
- config.Version = "v1"
- }
-
- if len(config.UserAgent) == 0 {
- config.UserAgent = "OpenWhisk-Go-Client"
- }
-
- c := &Client{
- client: httpClient,
- Config: config,
- }
-
- c.Sdks = &SdkService{client: c}
- c.Triggers = &TriggerService{client: c}
- c.Actions = &ActionService{client: c}
- c.Rules = &RuleService{client: c}
- c.Activations = &ActivationService{client: c}
- c.Packages = &PackageService{client: c}
- c.Namespaces = &NamespaceService{client: c}
- c.Info = &InfoService{client: c}
- c.Apis = &ApiService{client: c}
-
- return c, nil
+ var config *Config
+ if config_input == nil {
+ defaultConfig, err := GetDefaultConfig()
+ if err != nil {
+ return nil, err
+ } else {
+ config = defaultConfig
+ }
+ } else {
+ config = config_input
+ }
+
+ if httpClient == nil {
+ httpClient = &http.Client{
+ Timeout: time.Second * DEFAULT_HTTP_TIMEOUT,
+ }
+ }
+
+ var err error
+ var errStr = ""
+ if len(config.Host) == 0 {
+ errStr = wski18n.T("Unable to create request URL, because OpenWhisk API host is missing")
+ } else if config.BaseURL == nil {
+ config.BaseURL, err = GetUrlBase(config.Host)
+ if err != nil {
+ Debug(DbgError, "Unable to create request URL, because the api host %s is invalid\n", config.Host, err)
+ errStr = wski18n.T("Unable to create request URL, because the api host '{{.host}}' is invalid: {{.err}}",
+ map[string]interface{}{"host": config.Host, "err": err})
+ }
+ }
+
+ if len(errStr) != 0 {
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+
+ if len(config.Namespace) == 0 {
+ config.Namespace = "_"
+ }
+
+ if len(config.Version) == 0 {
+ config.Version = "v1"
+ }
+
+ if len(config.UserAgent) == 0 {
+ config.UserAgent = "OpenWhisk-Go-Client"
+ }
+
+ c := &Client{
+ client: httpClient,
+ Config: config,
+ }
+
+ c.Sdks = &SdkService{client: c}
+ c.Triggers = &TriggerService{client: c}
+ c.Actions = &ActionService{client: c}
+ c.Rules = &RuleService{client: c}
+ c.Activations = &ActivationService{client: c}
+ c.Packages = &PackageService{client: c}
+ c.Namespaces = &NamespaceService{client: c}
+ c.Info = &InfoService{client: c}
+ c.Apis = &ApiService{client: c}
+
+ return c, nil
}
func (c *Client) LoadX509KeyPair() error {
- tlsConfig := &tls.Config {
- InsecureSkipVerify: c.Config.Insecure,
- }
-
- if c.Config.Cert != "" && c.Config.Key != "" {
- if cert, err := ReadX509KeyPair(c.Config.Cert, c.Config.Key); err == nil {
- tlsConfig.Certificates = []tls.Certificate{cert}
- } else {
- errStr := wski18n.T("Unable to load the X509 key pair due to the following reason: {{.err}}",
- map[string]interface{}{"err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return werr
- }
- } else if !c.Config.Insecure {
- if c.Config.Cert == "" {
- warningStr := "The Cert file is not configured. Please configure the missing Cert file, if there is a security issue accessing the service.\n"
- Debug(DbgWarn, warningStr)
- if c.Config.Key != "" {
- errStr := wski18n.T("The Cert file is not configured. Please configure the missing Cert file.\n")
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return werr
- }
- }
- if c.Config.Key == "" {
- warningStr := "The Key file is not configured. Please configure the missing Key file, if there is a security issue accessing the service.\n"
- Debug(DbgWarn, warningStr)
- if c.Config.Cert != "" {
- errStr := wski18n.T("The Key file is not configured. Please configure the missing Key file.\n")
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return werr
- }
- }
- }
-
- c.client.Transport = &http.Transport{
- TLSClientConfig: tlsConfig,
- }
-
- return nil
+ tlsConfig := &tls.Config{
+ InsecureSkipVerify: c.Config.Insecure,
+ }
+
+ if c.Config.Cert != "" && c.Config.Key != "" {
+ if cert, err := ReadX509KeyPair(c.Config.Cert, c.Config.Key); err == nil {
+ tlsConfig.Certificates = []tls.Certificate{cert}
+ } else {
+ errStr := wski18n.T("Unable to load the X509 key pair due to the following reason: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return werr
+ }
+ } else if !c.Config.Insecure {
+ if c.Config.Cert == "" {
+ warningStr := "The Cert file is not configured. Please configure the missing Cert file, if there is a security issue accessing the service.\n"
+ Debug(DbgWarn, warningStr)
+ if c.Config.Key != "" {
+ errStr := wski18n.T("The Cert file is not configured. Please configure the missing Cert file.\n")
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return werr
+ }
+ }
+ if c.Config.Key == "" {
+ warningStr := "The Key file is not configured. Please configure the missing Key file, if there is a security issue accessing the service.\n"
+ Debug(DbgWarn, warningStr)
+ if c.Config.Cert != "" {
+ errStr := wski18n.T("The Key file is not configured. Please configure the missing Key file.\n")
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return werr
+ }
+ }
+ }
+
+ c.client.Transport = &http.Transport{
+ TLSClientConfig: tlsConfig,
+ }
+
+ return nil
}
var ReadX509KeyPair = func(certFile, keyFile string) (tls.Certificate, error) {
- return tls.LoadX509KeyPair(certFile, keyFile)
+ return tls.LoadX509KeyPair(certFile, keyFile)
}
///////////////////////////////
@@ -212,108 +212,108 @@ var ReadX509KeyPair = func(certFile, keyFile string) (tls.Certificate, error) {
///////////////////////////////
func (c *Client) NewRequest(method, urlStr string, body interface{}, includeNamespaceInUrl bool) (*http.Request, error) {
- werr := c.LoadX509KeyPair()
- if werr != nil {
- return nil, werr
- }
-
- if (includeNamespaceInUrl) {
- if c.Config.Namespace != "" {
- urlStr = fmt.Sprintf("%s/namespaces/%s/%s", c.Config.Version, c.Config.Namespace, urlStr)
- } else {
- urlStr = fmt.Sprintf("%s/namespaces", c.Config.Version)
- }
- } else {
- urlStr = fmt.Sprintf("%s/%s", c.Config.Version, urlStr)
- }
-
- urlStr = fmt.Sprintf("%s/%s", c.BaseURL.String(), urlStr)
- u, err := url.Parse(urlStr)
- if err != nil {
- Debug(DbgError, "url.Parse(%s) error: %s\n", urlStr, err)
- errStr := wski18n.T("Invalid request URL '{{.url}}': {{.err}}",
- map[string]interface{}{"url": urlStr, "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
-
- var buf io.ReadWriter
- if body != nil {
- buf = new(bytes.Buffer)
- encoder := json.NewEncoder(buf)
- encoder.SetEscapeHTML(false)
- err := encoder.Encode(body)
-
- if err != nil {
- Debug(DbgError, "json.Encode(%#v) error: %s\n", body, err)
- errStr := wski18n.T("Error encoding request body: {{.err}}", map[string]interface{}{"err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
- }
-
- req, err := http.NewRequest(method, u.String(), buf)
- if err != nil {
- Debug(DbgError, "http.NewRequest(%v, %s, buf) error: %s\n", method, u.String(), err)
- errStr := wski18n.T("Error initializing request: {{.err}}", map[string]interface{}{"err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
- if req.Body != nil {
- req.Header.Add("Content-Type", "application/json")
- }
-
- err = c.addAuthHeader(req, AuthRequired)
- if err != nil {
- Debug(DbgError, "addAuthHeader() error: %s\n", err)
- errStr := wski18n.T("Unable to add the HTTP authentication header: {{.err}}",
- map[string]interface{}{"err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
-
- req.Header.Add("User-Agent", c.Config.UserAgent)
-
- return req, nil
+ werr := c.LoadX509KeyPair()
+ if werr != nil {
+ return nil, werr
+ }
+
+ if includeNamespaceInUrl {
+ if c.Config.Namespace != "" {
+ urlStr = fmt.Sprintf("%s/namespaces/%s/%s", c.Config.Version, c.Config.Namespace, urlStr)
+ } else {
+ urlStr = fmt.Sprintf("%s/namespaces", c.Config.Version)
+ }
+ } else {
+ urlStr = fmt.Sprintf("%s/%s", c.Config.Version, urlStr)
+ }
+
+ urlStr = fmt.Sprintf("%s/%s", c.BaseURL.String(), urlStr)
+ u, err := url.Parse(urlStr)
+ if err != nil {
+ Debug(DbgError, "url.Parse(%s) error: %s\n", urlStr, err)
+ errStr := wski18n.T("Invalid request URL '{{.url}}': {{.err}}",
+ map[string]interface{}{"url": urlStr, "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+
+ var buf io.ReadWriter
+ if body != nil {
+ buf = new(bytes.Buffer)
+ encoder := json.NewEncoder(buf)
+ encoder.SetEscapeHTML(false)
+ err := encoder.Encode(body)
+
+ if err != nil {
+ Debug(DbgError, "json.Encode(%#v) error: %s\n", body, err)
+ errStr := wski18n.T("Error encoding request body: {{.err}}", map[string]interface{}{"err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+ }
+
+ req, err := http.NewRequest(method, u.String(), buf)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(%v, %s, buf) error: %s\n", method, u.String(), err)
+ errStr := wski18n.T("Error initializing request: {{.err}}", map[string]interface{}{"err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+ if req.Body != nil {
+ req.Header.Add("Content-Type", "application/json")
+ }
+
+ err = c.addAuthHeader(req, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "addAuthHeader() error: %s\n", err)
+ errStr := wski18n.T("Unable to add the HTTP authentication header: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+
+ req.Header.Add("User-Agent", c.Config.UserAgent)
+
+ return req, nil
}
func (c *Client) addAuthHeader(req *http.Request, authRequired bool) error {
- if c.Config.AuthToken != "" {
- encodedAuthToken := base64.StdEncoding.EncodeToString([]byte(c.Config.AuthToken))
- req.Header.Add("Authorization", fmt.Sprintf("Basic %s", encodedAuthToken))
- Debug(DbgInfo, "Adding basic auth header; using authkey\n")
- } else {
- if authRequired {
- Debug(DbgError, "The required authorization key is not configured - neither set as a property nor set via the --auth CLI argument\n")
- errStr := wski18n.T("Authorization key is not configured (--auth is required)")
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_USAGE, DISPLAY_MSG, DISPLAY_USAGE)
- return werr
- }
- }
- return nil
+ if c.Config.AuthToken != "" {
+ encodedAuthToken := base64.StdEncoding.EncodeToString([]byte(c.Config.AuthToken))
+ req.Header.Add("Authorization", fmt.Sprintf("Basic %s", encodedAuthToken))
+ Debug(DbgInfo, "Adding basic auth header; using authkey\n")
+ } else {
+ if authRequired {
+ Debug(DbgError, "The required authorization key is not configured - neither set as a property nor set via the --auth CLI argument\n")
+ errStr := wski18n.T("Authorization key is not configured (--auth is required)")
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_USAGE, DISPLAY_MSG, DISPLAY_USAGE)
+ return werr
+ }
+ }
+ return nil
}
// bodyTruncator limits the size of Req/Resp Body for --verbose ONLY.
// It returns truncated Req/Resp Body, reloaded io.ReadCloser and any errors.
func BodyTruncator(body io.ReadCloser) (string, io.ReadCloser, error) {
- limit := 1000 // 1000 byte limit, anything over is truncated
+ limit := 1000 // 1000 byte limit, anything over is truncated
- data, err := ioutil.ReadAll(body)
- if err != nil {
- Verbose("ioutil.ReadAll(req.Body) error: %s\n", err)
- werr := MakeWskError(err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return "", body, werr
- }
+ data, err := ioutil.ReadAll(body)
+ if err != nil {
+ Verbose("ioutil.ReadAll(req.Body) error: %s\n", err)
+ werr := MakeWskError(err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return "", body, werr
+ }
- reload := ioutil.NopCloser(bytes.NewBuffer(data))
+ reload := ioutil.NopCloser(bytes.NewBuffer(data))
- if len(data) > limit {
- Verbose("Body exceeds %d bytes and will be truncated\n", limit)
- newData := string(data)[:limit] + "..."
- return string(newData), reload, nil
- }
+ if len(data) > limit {
+ Verbose("Body exceeds %d bytes and will be truncated\n", limit)
+ newData := string(data)[:limit] + "..."
+ return string(newData), reload, nil
+ }
- return string(data), reload, nil
+ return string(data), reload, nil
}
// Do sends an API request and returns the API response. The API response is
@@ -322,262 +322,262 @@ func BodyTruncator(body io.ReadCloser) (string, io.ReadCloser, error) {
// interface, the raw response body will be written to v, without attempting to
// first decode it.
func (c *Client) Do(req *http.Request, v interface{}, ExitWithErrorOnTimeout bool, secretToObfuscate ...ObfuscateSet) (*http.Response, error) {
- var err error
- var data []byte
- secrets := append(DefaultObfuscateArr, secretToObfuscate...)
-
- req, err = PrintRequestInfo(req, secrets...)
- //Putting this based on previous code
- if err != nil {
- return nil, err
- }
-
- // Issue the request to the Whisk server endpoint
- resp, err := c.client.Do(req)
- if err != nil {
- Debug(DbgError, "HTTP Do() [req %s] error: %s\n", req.URL.String(), err)
- werr := MakeWskError(err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
-
- resp, data, err = PrintResponseInfo(resp, secrets...)
- if err != nil {
- return resp, err
- }
-
- // With the HTTP response status code and the HTTP body contents,
- // the possible response scenarios are:
- //
- // 0. HTTP Success + Body indicating a whisk failure result
- // 1. HTTP Success + Valid body matching request expectations
- // 2. HTTP Success + No body expected
- // 3. HTTP Success + Body does NOT match request expectations
- // 4. HTTP Failure + No body
- // 5. HTTP Failure + Body matching error format expectation
- // 6. HTTP Failure + Body NOT matching error format expectation
-
- // Handle 4. HTTP Failure + No body
- // If this happens, just return no data and an error
- if !IsHttpRespSuccess(resp) && data == nil {
- Debug(DbgError, "HTTP failure %d + no body\n", resp.StatusCode)
- werr := MakeWskError(errors.New(wski18n.T("Command failed due to an HTTP failure")), resp.StatusCode-256,
- DISPLAY_MSG, NO_DISPLAY_USAGE)
- return resp, werr
- }
-
- // Handle 5. HTTP Failure + Body matching error format expectation, or body matching a whisk.error() response
- // Handle 6. HTTP Failure + Body NOT matching error format expectation
- if !IsHttpRespSuccess(resp) && data != nil {
- return parseErrorResponse(resp, data, v)
- }
-
- // Handle 0. HTTP Success + Body indicating a whisk failure result
- // NOTE: Need to ignore activation records send in response to 'wsk get activation NNN` as
- // these will report the same original error giving the appearance that the command failed.
- // Need to ignore `wsk action invoke NNN --result` too, otherwise action whose result is sth likes
- // '{"response": {"key": "value"}}' will return an error to such command.
- if (IsHttpRespSuccess(resp) && // HTTP Status == 200
- data!=nil && // HTTP response body exists
- v != nil &&
- !strings.Contains(reflect.TypeOf(v).String(), "Activation") && // Request is not `wsk activation get`
- !(req.URL.Query().Get("result") == "true") && // Request is not `wsk action invoke NNN --result`
- !IsResponseResultSuccess(data)) { // HTTP response body has Whisk error result
- Debug(DbgInfo, "Got successful HTTP; but activation response reports an error\n")
- return parseErrorResponse(resp, data, v)
- }
-
- // Handle 2. HTTP Success + No body expected
- if IsHttpRespSuccess(resp) && v == nil {
- Debug(DbgInfo, "No interface provided; no HTTP response body expected\n")
- return resp, nil
- }
-
- // Handle 1. HTTP Success + Valid body matching request expectations
- // Handle 3. HTTP Success + Body does NOT match request expectations
- if IsHttpRespSuccess(resp) && v != nil {
-
- // If a timeout occurs, 202 HTTP status code is returned, and the caller wishes to handle such an event, return
- // an error corresponding with the timeout
- if ExitWithErrorOnTimeout && resp.StatusCode == EXIT_CODE_TIMED_OUT {
- errMsg := wski18n.T("Request accepted, but processing not completed yet.")
- err = MakeWskError(errors.New(errMsg), EXIT_CODE_TIMED_OUT, NO_DISPLAY_MSG, NO_DISPLAY_USAGE,
- NO_MSG_DISPLAYED, NO_DISPLAY_PREFIX, NO_APPLICATION_ERR, TIMED_OUT)
- }
-
- return parseSuccessResponse(resp, data, v), err
- }
-
- // We should never get here, but just in case return failure to keep the compiler happy
- werr := MakeWskError(errors.New(wski18n.T("Command failed due to an internal failure")), EXIT_CODE_ERR_GENERAL,
- DISPLAY_MSG, NO_DISPLAY_USAGE)
- return resp, werr
+ var err error
+ var data []byte
+ secrets := append(DefaultObfuscateArr, secretToObfuscate...)
+
+ req, err = PrintRequestInfo(req, secrets...)
+ //Putting this based on previous code
+ if err != nil {
+ return nil, err
+ }
+
+ // Issue the request to the Whisk server endpoint
+ resp, err := c.client.Do(req)
+ if err != nil {
+ Debug(DbgError, "HTTP Do() [req %s] error: %s\n", req.URL.String(), err)
+ werr := MakeWskError(err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+
+ resp, data, err = PrintResponseInfo(resp, secrets...)
+ if err != nil {
+ return resp, err
+ }
+
+ // With the HTTP response status code and the HTTP body contents,
+ // the possible response scenarios are:
+ //
+ // 0. HTTP Success + Body indicating a whisk failure result
+ // 1. HTTP Success + Valid body matching request expectations
+ // 2. HTTP Success + No body expected
+ // 3. HTTP Success + Body does NOT match request expectations
+ // 4. HTTP Failure + No body
+ // 5. HTTP Failure + Body matching error format expectation
+ // 6. HTTP Failure + Body NOT matching error format expectation
+
+ // Handle 4. HTTP Failure + No body
+ // If this happens, just return no data and an error
+ if !IsHttpRespSuccess(resp) && data == nil {
+ Debug(DbgError, "HTTP failure %d + no body\n", resp.StatusCode)
+ werr := MakeWskError(errors.New(wski18n.T("Command failed due to an HTTP failure")), resp.StatusCode-256,
+ DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return resp, werr
+ }
+
+ // Handle 5. HTTP Failure + Body matching error format expectation, or body matching a whisk.error() response
+ // Handle 6. HTTP Failure + Body NOT matching error format expectation
+ if !IsHttpRespSuccess(resp) && data != nil {
+ return parseErrorResponse(resp, data, v)
+ }
+
+ // Handle 0. HTTP Success + Body indicating a whisk failure result
+ // NOTE: Need to ignore activation records send in response to 'wsk get activation NNN` as
+ // these will report the same original error giving the appearance that the command failed.
+ // Need to ignore `wsk action invoke NNN --result` too, otherwise action whose result is sth likes
+ // '{"response": {"key": "value"}}' will return an error to such command.
+ if IsHttpRespSuccess(resp) && // HTTP Status == 200
+ data != nil && // HTTP response body exists
+ v != nil &&
+ !strings.Contains(reflect.TypeOf(v).String(), "Activation") && // Request is not `wsk activation get`
+ !(req.URL.Query().Get("result") == "true") && // Request is not `wsk action invoke NNN --result`
+ !IsResponseResultSuccess(data) { // HTTP response body has Whisk error result
+ Debug(DbgInfo, "Got successful HTTP; but activation response reports an error\n")
+ return parseErrorResponse(resp, data, v)
+ }
+
+ // Handle 2. HTTP Success + No body expected
+ if IsHttpRespSuccess(resp) && v == nil {
+ Debug(DbgInfo, "No interface provided; no HTTP response body expected\n")
+ return resp, nil
+ }
+
+ // Handle 1. HTTP Success + Valid body matching request expectations
+ // Handle 3. HTTP Success + Body does NOT match request expectations
+ if IsHttpRespSuccess(resp) && v != nil {
+
+ // If a timeout occurs, 202 HTTP status code is returned, and the caller wishes to handle such an event, return
+ // an error corresponding with the timeout
+ if ExitWithErrorOnTimeout && resp.StatusCode == EXIT_CODE_TIMED_OUT {
+ errMsg := wski18n.T("Request accepted, but processing not completed yet.")
+ err = MakeWskError(errors.New(errMsg), EXIT_CODE_TIMED_OUT, NO_DISPLAY_MSG, NO_DISPLAY_USAGE,
+ NO_MSG_DISPLAYED, NO_DISPLAY_PREFIX, NO_APPLICATION_ERR, TIMED_OUT)
+ }
+
+ return parseSuccessResponse(resp, data, v), err
+ }
+
+ // We should never get here, but just in case return failure to keep the compiler happy
+ werr := MakeWskError(errors.New(wski18n.T("Command failed due to an internal failure")), EXIT_CODE_ERR_GENERAL,
+ DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return resp, werr
}
func PrintRequestInfo(req *http.Request, secretToObfuscate ...ObfuscateSet) (*http.Request, error) {
- var truncatedBody string
- var err error
- if IsVerbose() {
- fmt.Println("REQUEST:")
- fmt.Printf("[%s]\t%s\n", req.Method, req.URL)
-
- if len(req.Header) > 0 {
- fmt.Println("Req Headers")
- PrintJSON(req.Header)
- }
-
- if req.Body != nil {
- fmt.Println("Req Body")
- // Since we're emptying out the reader, which is the req.Body, we have to reset it,
- // but create some copies for our debug messages.
- buffer, _ := ioutil.ReadAll(req.Body)
- obfuscatedRequest := ObfuscateText(string(buffer), secretToObfuscate)
- req.Body = ioutil.NopCloser(bytes.NewBuffer(buffer))
-
- if !IsDebug() {
- if truncatedBody, req.Body, err = BodyTruncator(ioutil.NopCloser(bytes.NewBuffer(buffer))); err != nil {
- return nil, err
- }
- fmt.Println(ObfuscateText(truncatedBody, secretToObfuscate))
- } else {
- fmt.Println(obfuscatedRequest)
- }
- Debug(DbgInfo, "Req Body (ASCII quoted string):\n%+q\n", obfuscatedRequest)
- }
- }
- return req, nil
+ var truncatedBody string
+ var err error
+ if IsVerbose() {
+ fmt.Println("REQUEST:")
+ fmt.Printf("[%s]\t%s\n", req.Method, req.URL)
+
+ if len(req.Header) > 0 {
+ fmt.Println("Req Headers")
+ PrintJSON(req.Header)
+ }
+
+ if req.Body != nil {
+ fmt.Println("Req Body")
+ // Since we're emptying out the reader, which is the req.Body, we have to reset it,
+ // but create some copies for our debug messages.
+ buffer, _ := ioutil.ReadAll(req.Body)
+ obfuscatedRequest := ObfuscateText(string(buffer), secretToObfuscate)
+ req.Body = ioutil.NopCloser(bytes.NewBuffer(buffer))
+
+ if !IsDebug() {
+ if truncatedBody, req.Body, err = BodyTruncator(ioutil.NopCloser(bytes.NewBuffer(buffer))); err != nil {
+ return nil, err
+ }
+ fmt.Println(ObfuscateText(truncatedBody, secretToObfuscate))
+ } else {
+ fmt.Println(obfuscatedRequest)
+ }
+ Debug(DbgInfo, "Req Body (ASCII quoted string):\n%+q\n", obfuscatedRequest)
+ }
+ }
+ return req, nil
}
func PrintResponseInfo(resp *http.Response, secretToObfuscate ...ObfuscateSet) (*http.Response, []byte, error) {
- var truncatedBody string
- // Don't "defer resp.Body.Close()" here because the body is reloaded to allow caller to
- // do custom body parsing, such as handling per-route error responses.
- Verbose("RESPONSE:")
- Verbose("Got response with code %d\n", resp.StatusCode)
-
- if (IsVerbose() && len(resp.Header) > 0) {
- fmt.Println("Resp Headers")
- PrintJSON(resp.Header)
- }
-
- // Read the response body
- data, err := ioutil.ReadAll(resp.Body)
- if err != nil {
- Debug(DbgError, "ioutil.ReadAll(resp.Body) error: %s\n", err)
- werr := MakeWskError(err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
- resp.Body = ioutil.NopCloser(bytes.NewBuffer(data))
- return resp, data, werr
- }
-
- // Reload the response body to allow caller access to the body; otherwise,
- // the caller will have any empty body to read
- resp.Body = ioutil.NopCloser(bytes.NewBuffer(data))
-
- Verbose("Response body size is %d bytes\n", len(data))
-
- if !IsDebug() {
- if truncatedBody, resp.Body, err = BodyTruncator(ioutil.NopCloser(bytes.NewBuffer(data))); err != nil {
- return nil, data, err
- }
- Verbose("Response body received:\n%s\n", ObfuscateText(truncatedBody, secretToObfuscate))
- } else {
- obfuscatedResponse := ObfuscateText(string(data), secretToObfuscate)
- Verbose("Response body received:\n%s\n", obfuscatedResponse)
- Debug(DbgInfo, "Response body received (ASCII quoted string):\n%+q\n", obfuscatedResponse)
- }
- return resp, data, err
+ var truncatedBody string
+ // Don't "defer resp.Body.Close()" here because the body is reloaded to allow caller to
+ // do custom body parsing, such as handling per-route error responses.
+ Verbose("RESPONSE:")
+ Verbose("Got response with code %d\n", resp.StatusCode)
+
+ if IsVerbose() && len(resp.Header) > 0 {
+ fmt.Println("Resp Headers")
+ PrintJSON(resp.Header)
+ }
+
+ // Read the response body
+ data, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ Debug(DbgError, "ioutil.ReadAll(resp.Body) error: %s\n", err)
+ werr := MakeWskError(err, EXIT_CODE_ERR_NETWORK, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ resp.Body = ioutil.NopCloser(bytes.NewBuffer(data))
+ return resp, data, werr
+ }
+
+ // Reload the response body to allow caller access to the body; otherwise,
+ // the caller will have any empty body to read
+ resp.Body = ioutil.NopCloser(bytes.NewBuffer(data))
+
+ Verbose("Response body size is %d bytes\n", len(data))
+
+ if !IsDebug() {
+ if truncatedBody, resp.Body, err = BodyTruncator(ioutil.NopCloser(bytes.NewBuffer(data))); err != nil {
+ return nil, data, err
+ }
+ Verbose("Response body received:\n%s\n", ObfuscateText(truncatedBody, secretToObfuscate))
+ } else {
+ obfuscatedResponse := ObfuscateText(string(data), secretToObfuscate)
+ Verbose("Response body received:\n%s\n", obfuscatedResponse)
+ Debug(DbgInfo, "Response body received (ASCII quoted string):\n%+q\n", obfuscatedResponse)
+ }
+ return resp, data, err
}
func ObfuscateText(text string, replacements []ObfuscateSet) string {
- obfuscated := text
- for _, oSet := range replacements {
- r, _ := regexp.Compile(oSet.Regex)
- obfuscated = r.ReplaceAllString(obfuscated, oSet.Replacement)
- }
- return obfuscated
+ obfuscated := text
+ for _, oSet := range replacements {
+ r, _ := regexp.Compile(oSet.Regex)
+ obfuscated = r.ReplaceAllString(obfuscated, oSet.Replacement)
+ }
+ return obfuscated
}
func parseErrorResponse(resp *http.Response, data []byte, v interface{}) (*http.Response, error) {
- Debug(DbgInfo, "HTTP failure %d + body\n", resp.StatusCode)
-
- // Determine if an application error was received (#5)
- errorResponse := &ErrorResponse{Response: resp}
- err := json.Unmarshal(data, errorResponse)
-
- // Determine if error is an application error or an error generated by API
- if err == nil {
- if errorResponse.Code == nil /*&& errorResponse.ErrMsg != nil */&& resp.StatusCode == 502 {
- return parseApplicationError(resp, data, v)
- } else if errorResponse.Code != nil && errorResponse.ErrMsg != nil {
- Debug(DbgInfo, "HTTP failure %d; server error %s\n", resp.StatusCode, errorResponse)
- werr := MakeWskError(errorResponse, resp.StatusCode - 256, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return resp, werr
- }
- }
-
- // Body contents are unknown (#6)
- Debug(DbgError, "HTTP response with unexpected body failed due to contents parsing error: '%v'\n", err)
- errMsg := wski18n.T("The connection failed, or timed out. (HTTP status code {{.code}})",
- map[string]interface{}{"code": resp.StatusCode})
- whiskErr := MakeWskError(errors.New(errMsg), resp.StatusCode - 256, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return resp, whiskErr
+ Debug(DbgInfo, "HTTP failure %d + body\n", resp.StatusCode)
+
+ // Determine if an application error was received (#5)
+ errorResponse := &ErrorResponse{Response: resp}
+ err := json.Unmarshal(data, errorResponse)
+
+ // Determine if error is an application error or an error generated by API
+ if err == nil {
+ if errorResponse.Code == nil /*&& errorResponse.ErrMsg != nil */ && resp.StatusCode == 502 {
+ return parseApplicationError(resp, data, v)
+ } else if errorResponse.Code != nil && errorResponse.ErrMsg != nil {
+ Debug(DbgInfo, "HTTP failure %d; server error %s\n", resp.StatusCode, errorResponse)
+ werr := MakeWskError(errorResponse, resp.StatusCode-256, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return resp, werr
+ }
+ }
+
+ // Body contents are unknown (#6)
+ Debug(DbgError, "HTTP response with unexpected body failed due to contents parsing error: '%v'\n", err)
+ errMsg := wski18n.T("The connection failed, or timed out. (HTTP status code {{.code}})",
+ map[string]interface{}{"code": resp.StatusCode})
+ whiskErr := MakeWskError(errors.New(errMsg), resp.StatusCode-256, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return resp, whiskErr
}
func parseApplicationError(resp *http.Response, data []byte, v interface{}) (*http.Response, error) {
- Debug(DbgInfo, "Parsing application error\n")
-
- whiskErrorResponse := &WhiskErrorResponse{}
- err := json.Unmarshal(data, whiskErrorResponse)
-
- // Handle application errors that occur when --result option is false (#5)
- if err == nil && whiskErrorResponse != nil && whiskErrorResponse.Response != nil && whiskErrorResponse.Response.Status != nil {
- Debug(DbgInfo, "Detected response status `%s` that a whisk.error(\"%#v\") was returned\n",
- *whiskErrorResponse.Response.Status, *whiskErrorResponse.Response.Result)
- errMsg := wski18n.T("The following application error was received: {{.err}}",
- map[string]interface{}{"err": *whiskErrorResponse.Response.Result})
- whiskErr := MakeWskError(errors.New(errMsg), resp.StatusCode - 256, NO_DISPLAY_MSG, NO_DISPLAY_USAGE,
- NO_MSG_DISPLAYED, DISPLAY_PREFIX, APPLICATION_ERR)
- return parseSuccessResponse(resp, data, v), whiskErr
- }
-
- appErrResult := &AppErrorResult{}
- err = json.Unmarshal(data, appErrResult)
-
- // Handle application errors that occur with blocking invocations when --result option is true (#5)
- if err == nil && appErrResult.Error != nil {
- Debug(DbgInfo, "Error code is null, blocking with result invocation error has occured\n")
- errMsg := fmt.Sprintf("%v", *appErrResult.Error)
- Debug(DbgInfo, "Application error received: %s\n", errMsg)
-
- whiskErr := MakeWskError(errors.New(errMsg), resp.StatusCode - 256, NO_DISPLAY_MSG, NO_DISPLAY_USAGE,
- NO_MSG_DISPLAYED, DISPLAY_PREFIX, APPLICATION_ERR)
- return parseSuccessResponse(resp, data, v), whiskErr
- }
-
- // Body contents are unknown (#6)
- Debug(DbgError, "HTTP response with unexpected body failed due to contents parsing error: '%v'\n", err)
- errMsg := wski18n.T("The connection failed, or timed out. (HTTP status code {{.code}})",
- map[string]interface{}{"code": resp.StatusCode})
- whiskErr := MakeWskError(errors.New(errMsg), resp.StatusCode - 256, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return resp, whiskErr
+ Debug(DbgInfo, "Parsing application error\n")
+
+ whiskErrorResponse := &WhiskErrorResponse{}
+ err := json.Unmarshal(data, whiskErrorResponse)
+
+ // Handle application errors that occur when --result option is false (#5)
+ if err == nil && whiskErrorResponse != nil && whiskErrorResponse.Response != nil && whiskErrorResponse.Response.Status != nil {
+ Debug(DbgInfo, "Detected response status `%s` that a whisk.error(\"%#v\") was returned\n",
+ *whiskErrorResponse.Response.Status, *whiskErrorResponse.Response.Result)
+ errMsg := wski18n.T("The following application error was received: {{.err}}",
+ map[string]interface{}{"err": *whiskErrorResponse.Response.Result})
+ whiskErr := MakeWskError(errors.New(errMsg), resp.StatusCode-256, NO_DISPLAY_MSG, NO_DISPLAY_USAGE,
+ NO_MSG_DISPLAYED, DISPLAY_PREFIX, APPLICATION_ERR)
+ return parseSuccessResponse(resp, data, v), whiskErr
+ }
+
+ appErrResult := &AppErrorResult{}
+ err = json.Unmarshal(data, appErrResult)
+
+ // Handle application errors that occur with blocking invocations when --result option is true (#5)
+ if err == nil && appErrResult.Error != nil {
+ Debug(DbgInfo, "Error code is null, blocking with result invocation error has occured\n")
+ errMsg := fmt.Sprintf("%v", *appErrResult.Error)
+ Debug(DbgInfo, "Application error received: %s\n", errMsg)
+
+ whiskErr := MakeWskError(errors.New(errMsg), resp.StatusCode-256, NO_DISPLAY_MSG, NO_DISPLAY_USAGE,
+ NO_MSG_DISPLAYED, DISPLAY_PREFIX, APPLICATION_ERR)
+ return parseSuccessResponse(resp, data, v), whiskErr
+ }
+
+ // Body contents are unknown (#6)
+ Debug(DbgError, "HTTP response with unexpected body failed due to contents parsing error: '%v'\n", err)
+ errMsg := wski18n.T("The connection failed, or timed out. (HTTP status code {{.code}})",
+ map[string]interface{}{"code": resp.StatusCode})
+ whiskErr := MakeWskError(errors.New(errMsg), resp.StatusCode-256, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return resp, whiskErr
}
-func parseSuccessResponse(resp *http.Response, data []byte, v interface{}) (*http.Response) {
- Debug(DbgInfo, "Parsing HTTP response into struct type: %s\n", reflect.TypeOf(v))
-
- dc := json.NewDecoder(strings.NewReader(string(data)))
- dc.UseNumber()
- err := dc.Decode(v)
-
- // If the decode was successful, return the response without error (#1). Otherwise, the decode did not work, so the
- // server response was unexpected (#3)
- if err == nil {
- Debug(DbgInfo, "Successful parse of HTTP response into struct type: %s\n", reflect.TypeOf(v))
- return resp
- } else {
- Debug(DbgWarn, "Unsuccessful parse of HTTP response into struct type: %s; parse error '%v'\n", reflect.TypeOf(v), err)
- Debug(DbgWarn, "Request was successful, so ignoring the following unexpected response body that could not be parsed: %s\n", data)
- return resp
- }
+func parseSuccessResponse(resp *http.Response, data []byte, v interface{}) *http.Response {
+ Debug(DbgInfo, "Parsing HTTP response into struct type: %s\n", reflect.TypeOf(v))
+
+ dc := json.NewDecoder(strings.NewReader(string(data)))
+ dc.UseNumber()
+ err := dc.Decode(v)
+
+ // If the decode was successful, return the response without error (#1). Otherwise, the decode did not work, so the
+ // server response was unexpected (#3)
+ if err == nil {
+ Debug(DbgInfo, "Successful parse of HTTP response into struct type: %s\n", reflect.TypeOf(v))
+ return resp
+ } else {
+ Debug(DbgWarn, "Unsuccessful parse of HTTP response into struct type: %s; parse error '%v'\n", reflect.TypeOf(v), err)
+ Debug(DbgWarn, "Request was successful, so ignoring the following unexpected response body that could not be parsed: %s\n", data)
+ return resp
+ }
}
////////////
@@ -591,36 +591,36 @@ func parseSuccessResponse(resp *http.Response, data []byte, v interface{}) (*htt
// "code": 1422870
// }
type ErrorResponse struct {
- Response *http.Response // HTTP response that caused this error
- ErrMsg *interface{} `json:"error"` // error message string
- Code *int64 `json:"code"` // validation error code
+ Response *http.Response // HTTP response that caused this error
+ ErrMsg *interface{} `json:"error"` // error message string
+ Code *int64 `json:"code"` // validation error code
}
type AppErrorResult struct {
- Error *interface{} `json:"error"`
+ Error *interface{} `json:"error"`
}
type WhiskErrorResponse struct {
- Response *WhiskResponse `json:"response"`
+ Response *WhiskResponse `json:"response"`
}
type WhiskResponse struct {
- Result *WhiskResult `json:"result"`
- Success bool `json:"success"`
- Status *interface{} `json:"status"`
+ Result *WhiskResult `json:"result"`
+ Success bool `json:"success"`
+ Status *interface{} `json:"status"`
}
type WhiskResult struct {
-// Error *WhiskError `json:"error"` // whisk.error(<string>) and whisk.reject({msg:<string>}) result in two different kinds of 'error' JSON objects
+ // Error *WhiskError `json:"error"` // whisk.error(<string>) and whisk.reject({msg:<string>}) result in two different kinds of 'error' JSON objects
}
type WhiskError struct {
- Msg *string `json:"msg"`
+ Msg *string `json:"msg"`
}
func (r ErrorResponse) Error() string {
- return wski18n.T("{{.msg}} (code {{.code}})",
- map[string]interface{}{"msg": fmt.Sprintf("%v", *r.ErrMsg), "code": r.Code})
+ return wski18n.T("{{.msg}} (code {{.code}})",
+ map[string]interface{}{"msg": fmt.Sprintf("%v", *r.ErrMsg), "code": r.Code})
}
////////////////////////////
@@ -628,17 +628,17 @@ func (r ErrorResponse) Error() string {
////////////////////////////
func IsHttpRespSuccess(r *http.Response) bool {
- return r.StatusCode >= 200 && r.StatusCode <= 299
+ return r.StatusCode >= 200 && r.StatusCode <= 299
}
func IsResponseResultSuccess(data []byte) bool {
- errResp := new(WhiskErrorResponse)
- err := json.Unmarshal(data, &errResp)
- if (err == nil && errResp.Response != nil) {
- return errResp.Response.Success
- }
- Debug(DbgWarn, "IsResponseResultSuccess: failed to parse response result: %v\n", err)
- return true;
+ errResp := new(WhiskErrorResponse)
+ err := json.Unmarshal(data, &errResp)
+ if err == nil && errResp.Response != nil {
+ return errResp.Response.Success
+ }
+ Debug(DbgWarn, "IsResponseResultSuccess: failed to parse response result: %v\n", err)
+ return true
}
//
@@ -652,122 +652,122 @@ func IsResponseResultSuccess(data []byte) bool {
// encodeBodyAs - specifies body encoding (json or form data)
// useAuthentication - when true, the basic Authorization is included with the configured authkey as the value
func (c *Client) NewRequestUrl(
- method string,
- urlRelResource *url.URL,
- body interface{},
- includeNamespaceInUrl bool,
- appendOpenWhiskPath bool,
- encodeBodyAs string,
- useAuthentication bool) (*http.Request, error) {
- var requestUrl *url.URL
- var err error
- error := c.LoadX509KeyPair()
- if error != nil {
- return nil, error
- }
-
- if (appendOpenWhiskPath) {
- var urlVerNamespaceStr string
- var verPathEncoded = (&url.URL{Path: c.Config.Version}).String()
-
- if (includeNamespaceInUrl) {
- if c.Config.Namespace != "" {
- // Encode path parts before inserting them into the URI so that any '?' is correctly encoded
- // as part of the path and not the start of the query params
- verNamespaceEncoded := (&url.URL{Path: c.Config.Namespace}).String()
- urlVerNamespaceStr = fmt.Sprintf("%s/namespaces/%s", verPathEncoded, verNamespaceEncoded)
- } else {
- urlVerNamespaceStr = fmt.Sprintf("%s/namespaces", verPathEncoded)
- }
- } else {
- urlVerNamespaceStr = fmt.Sprintf("%s", verPathEncoded)
- }
-
- // Assemble the complete URL: base + version + [namespace] + resource_relative_path
- Debug(DbgInfo, "basepath: %s, version/namespace path: %s, resource path: %s\n", c.BaseURL.String(), urlVerNamespaceStr, urlRelResource.String())
- urlStr := fmt.Sprintf("%s/%s/%s", c.BaseURL.String(), urlVerNamespaceStr, urlRelResource.String())
- requestUrl, err = url.Parse(urlStr)
- if err != nil {
- Debug(DbgError, "url.Parse(%s) error: %s\n", urlStr, err)
- errStr := wski18n.T("Invalid request URL '{{.url}}': {{.err}}",
- map[string]interface{}{"url": urlStr, "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
- } else {
- Debug(DbgInfo, "basepath: %s, resource path: %s\n", c.BaseURL.String(), urlRelResource.String())
- urlStr := fmt.Sprintf("%s/%s", c.BaseURL.String(), urlRelResource.String())
- requestUrl, err = url.Parse(urlStr)
- if err != nil {
- Debug(DbgError, "url.Parse(%s) error: %s\n", urlStr, err)
- errStr := wski18n.T("Invalid request URL '{{.url}}': {{.err}}",
- map[string]interface{}{"url": urlStr, "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
- }
-
- var buf io.ReadWriter
- if body != nil {
- if (encodeBodyAs == EncodeBodyAsJson) {
- buf = new(bytes.Buffer)
- encoder := json.NewEncoder(buf)
- encoder.SetEscapeHTML(false)
- err := encoder.Encode(body)
-
- if err != nil {
- Debug(DbgError, "json.Encode(%#v) error: %s\n", body, err)
- errStr := wski18n.T("Error encoding request body: {{.err}}",
- map[string]interface{}{"err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
- } else if (encodeBodyAs == EncodeBodyAsFormData) {
- if values, ok := body.(url.Values); ok {
- buf = bytes.NewBufferString(values.Encode())
- } else {
- Debug(DbgError, "Invalid form data body: %v\n", body)
- errStr := wski18n.T("Internal error. Form data encoding failure")
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
- } else {
- Debug(DbgError, "Invalid body encode type: %s\n", encodeBodyAs)
- errStr := wski18n.T("Internal error. Invalid encoding type '{{.encodetype}}'",
- map[string]interface{}{"encodetype": encodeBodyAs})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
- }
-
- req, err := http.NewRequest(method, requestUrl.String(), buf)
- if err != nil {
- Debug(DbgError, "http.NewRequest(%v, %s, buf) error: %s\n", method, requestUrl.String(), err)
- errStr := wski18n.T("Error initializing request: {{.err}}", map[string]interface{}{"err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
- if (req.Body != nil && encodeBodyAs == EncodeBodyAsJson) {
- req.Header.Add("Content-Type", "application/json")
- }
- if (req.Body != nil && encodeBodyAs == EncodeBodyAsFormData) {
- req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
- }
-
- if useAuthentication {
- err = c.addAuthHeader(req, AuthRequired)
- if err != nil {
- Debug(DbgError, "addAuthHeader() error: %s\n", err)
- errStr := wski18n.T("Unable to add the HTTP authentication header: {{.err}}",
- map[string]interface{}{"err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
- } else {
- Debug(DbgInfo, "No auth header required\n")
- }
-
- req.Header.Add("User-Agent", c.Config.UserAgent)
-
- return req, nil
+ method string,
+ urlRelResource *url.URL,
+ body interface{},
+ includeNamespaceInUrl bool,
+ appendOpenWhiskPath bool,
+ encodeBodyAs string,
+ useAuthentication bool) (*http.Request, error) {
+ var requestUrl *url.URL
+ var err error
+ error := c.LoadX509KeyPair()
+ if error != nil {
+ return nil, error
+ }
+
+ if appendOpenWhiskPath {
+ var urlVerNamespaceStr string
+ var verPathEncoded = (&url.URL{Path: c.Config.Version}).String()
+
+ if includeNamespaceInUrl {
+ if c.Config.Namespace != "" {
+ // Encode path parts before inserting them into the URI so that any '?' is correctly encoded
+ // as part of the path and not the start of the query params
+ verNamespaceEncoded := (&url.URL{Path: c.Config.Namespace}).String()
+ urlVerNamespaceStr = fmt.Sprintf("%s/namespaces/%s", verPathEncoded, verNamespaceEncoded)
+ } else {
+ urlVerNamespaceStr = fmt.Sprintf("%s/namespaces", verPathEncoded)
+ }
+ } else {
+ urlVerNamespaceStr = fmt.Sprintf("%s", verPathEncoded)
+ }
+
+ // Assemble the complete URL: base + version + [namespace] + resource_relative_path
+ Debug(DbgInfo, "basepath: %s, version/namespace path: %s, resource path: %s\n", c.BaseURL.String(), urlVerNamespaceStr, urlRelResource.String())
+ urlStr := fmt.Sprintf("%s/%s/%s", c.BaseURL.String(), urlVerNamespaceStr, urlRelResource.String())
+ requestUrl, err = url.Parse(urlStr)
+ if err != nil {
+ Debug(DbgError, "url.Parse(%s) error: %s\n", urlStr, err)
+ errStr := wski18n.T("Invalid request URL '{{.url}}': {{.err}}",
+ map[string]interface{}{"url": urlStr, "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+ } else {
+ Debug(DbgInfo, "basepath: %s, resource path: %s\n", c.BaseURL.String(), urlRelResource.String())
+ urlStr := fmt.Sprintf("%s/%s", c.BaseURL.String(), urlRelResource.String())
+ requestUrl, err = url.Parse(urlStr)
+ if err != nil {
+ Debug(DbgError, "url.Parse(%s) error: %s\n", urlStr, err)
+ errStr := wski18n.T("Invalid request URL '{{.url}}': {{.err}}",
+ map[string]interface{}{"url": urlStr, "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+ }
+
+ var buf io.ReadWriter
+ if body != nil {
+ if encodeBodyAs == EncodeBodyAsJson {
+ buf = new(bytes.Buffer)
+ encoder := json.NewEncoder(buf)
+ encoder.SetEscapeHTML(false)
+ err := encoder.Encode(body)
+
+ if err != nil {
+ Debug(DbgError, "json.Encode(%#v) error: %s\n", body, err)
+ errStr := wski18n.T("Error encoding request body: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+ } else if encodeBodyAs == EncodeBodyAsFormData {
+ if values, ok := body.(url.Values); ok {
+ buf = bytes.NewBufferString(values.Encode())
+ } else {
+ Debug(DbgError, "Invalid form data body: %v\n", body)
+ errStr := wski18n.T("Internal error. Form data encoding failure")
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+ } else {
+ Debug(DbgError, "Invalid body encode type: %s\n", encodeBodyAs)
+ errStr := wski18n.T("Internal error. Invalid encoding type '{{.encodetype}}'",
+ map[string]interface{}{"encodetype": encodeBodyAs})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+ }
+
+ req, err := http.NewRequest(method, requestUrl.String(), buf)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(%v, %s, buf) error: %s\n", method, requestUrl.String(), err)
+ errStr := wski18n.T("Error initializing request: {{.err}}", map[string]interface{}{"err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+ if req.Body != nil && encodeBodyAs == EncodeBodyAsJson {
+ req.Header.Add("Content-Type", "application/json")
+ }
+ if req.Body != nil && encodeBodyAs == EncodeBodyAsFormData {
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+ }
+
+ if useAuthentication {
+ err = c.addAuthHeader(req, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "addAuthHeader() error: %s\n", err)
+ errStr := wski18n.T("Unable to add the HTTP authentication header: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+ } else {
+ Debug(DbgInfo, "No auth header required\n")
+ }
+
+ req.Header.Add("User-Agent", c.Config.UserAgent)
+
+ return req, nil
}
diff --git a/whisk/client_test.go b/whisk/client_test.go
index 1b3e748..ff1c63d 100644
--- a/whisk/client_test.go
+++ b/whisk/client_test.go
@@ -20,88 +20,88 @@
package whisk
import (
- "testing"
- "github.com/stretchr/testify/assert"
- "net/http"
- "fmt"
- "net/url"
+ "fmt"
+ "github.com/stretchr/testify/assert"
+ "net/http"
+ "net/url"
+ "testing"
)
const (
- FakeHost = "myUrl.com"
- FakeHostDiff = "myUrlTest.com"
- FakeBaseURL = "https://" + FakeHost + "/api"
- FakeBaseURLDiff = "https://" + FakeHostDiff + "/api"
- FakeNamespace = "my_namespace"
- FakeAuthKey = "dhajfhshfs:hjhfsjfdjfjsgfjs"
+ FakeHost = "myUrl.com"
+ FakeHostDiff = "myUrlTest.com"
+ FakeBaseURL = "https://" + FakeHost + "/api"
+ FakeBaseURLDiff = "https://" + FakeHostDiff + "/api"
+ FakeNamespace = "my_namespace"
+ FakeAuthKey = "dhajfhshfs:hjhfsjfdjfjsgfjs"
)
func GetValidConfigTest() *Config {
- var config Config
- config.Host = FakeHost
- config.Namespace = FakeNamespace
- config.AuthToken = FakeAuthKey
- return &config
+ var config Config
+ config.Host = FakeHost
+ config.Namespace = FakeNamespace
+ config.AuthToken = FakeAuthKey
+ return &config
}
func GetInvalidConfigMissingApiHostTest() *Config {
- var config Config
- config.Namespace = FakeNamespace
- config.AuthToken = FakeAuthKey
- return &config
+ var config Config
+ config.Namespace = FakeNamespace
+ config.AuthToken = FakeAuthKey
+ return &config
}
func GetInvalidConfigMissingApiHostWithBaseURLTest() *Config {
- var config Config
- urlBase := fmt.Sprintf("https://%s/api", FakeHostDiff)
- config.BaseURL, _ = url.Parse(urlBase)
- config.Namespace = FakeNamespace
- config.AuthToken = FakeAuthKey
- return &config
+ var config Config
+ urlBase := fmt.Sprintf("https://%s/api", FakeHostDiff)
+ config.BaseURL, _ = url.Parse(urlBase)
+ config.Namespace = FakeNamespace
+ config.AuthToken = FakeAuthKey
+ return &config
}
func GetValidConfigDiffApiHostAndBaseURLTest() *Config {
- var config Config
- urlBase := fmt.Sprintf("https://%s/api", FakeHostDiff)
- config.BaseURL, _ = url.Parse(urlBase)
- config.Host = FakeHost
- config.Namespace = FakeNamespace
- config.AuthToken = FakeAuthKey
- return &config
+ var config Config
+ urlBase := fmt.Sprintf("https://%s/api", FakeHostDiff)
+ config.BaseURL, _ = url.Parse(urlBase)
+ config.Host = FakeHost
+ config.Namespace = FakeNamespace
+ config.AuthToken = FakeAuthKey
+ return &config
}
func TestNewClient(t *testing.T) {
- // Test the use case to pass a valid config.
- config := GetValidConfigTest()
- client, err := NewClient(http.DefaultClient, config)
- assert.Nil(t, err)
- assert.NotNil(t, client)
- assert.Equal(t, FakeNamespace, client.Config.Namespace)
- assert.Equal(t, FakeHost, client.Config.Host)
- assert.Equal(t, FakeBaseURL, client.Config.BaseURL.String())
- assert.Equal(t, FakeAuthKey, client.Config.AuthToken)
+ // Test the use case to pass a valid config.
+ config := GetValidConfigTest()
+ client, err := NewClient(http.DefaultClient, config)
+ assert.Nil(t, err)
+ assert.NotNil(t, client)
+ assert.Equal(t, FakeNamespace, client.Config.Namespace)
+ assert.Equal(t, FakeHost, client.Config.Host)
+ assert.Equal(t, FakeBaseURL, client.Config.BaseURL.String())
+ assert.Equal(t, FakeAuthKey, client.Config.AuthToken)
- // Test the use case to pass an invalid config with a missing api host.
- config = GetInvalidConfigMissingApiHostTest()
- client, err = NewClient(http.DefaultClient, config)
- assert.NotNil(t, err)
- assert.Contains(t, err.Error(), "Unable to create request URL, because OpenWhisk API host is missing")
- assert.Nil(t, client)
+ // Test the use case to pass an invalid config with a missing api host.
+ config = GetInvalidConfigMissingApiHostTest()
+ client, err = NewClient(http.DefaultClient, config)
+ assert.NotNil(t, err)
+ assert.Contains(t, err.Error(), "Unable to create request URL, because OpenWhisk API host is missing")
+ assert.Nil(t, client)
- // Test the use case to pass a valid config with the base url but without api host.
- config = GetInvalidConfigMissingApiHostWithBaseURLTest()
- client, err = NewClient(http.DefaultClient, config)
- assert.NotNil(t, err)
- assert.Contains(t, err.Error(), "Unable to create request URL, because OpenWhisk API host is missing")
- assert.Nil(t, client)
+ // Test the use case to pass a valid config with the base url but without api host.
+ config = GetInvalidConfigMissingApiHostWithBaseURLTest()
+ client, err = NewClient(http.DefaultClient, config)
+ assert.NotNil(t, err)
+ assert.Contains(t, err.Error(), "Unable to create request URL, because OpenWhisk API host is missing")
+ assert.Nil(t, client)
- // Test the use case to pass a valid config with both the base and api host of different values.
- config = GetValidConfigDiffApiHostAndBaseURLTest()
- client, err = NewClient(http.DefaultClient, config)
- assert.Nil(t, err)
- assert.NotNil(t, client)
- assert.Equal(t, FakeNamespace, client.Config.Namespace)
- assert.Equal(t, FakeHost, client.Config.Host)
- assert.Equal(t, FakeBaseURLDiff, client.Config.BaseURL.String())
- assert.Equal(t, FakeAuthKey, client.Config.AuthToken)
+ // Test the use case to pass a valid config with both the base and api host of different values.
+ config = GetValidConfigDiffApiHostAndBaseURLTest()
+ client, err = NewClient(http.DefaultClient, config)
+ assert.Nil(t, err)
+ assert.NotNil(t, client)
+ assert.Equal(t, FakeNamespace, client.Config.Namespace)
+ assert.Equal(t, FakeHost, client.Config.Host)
+ assert.Equal(t, FakeBaseURLDiff, client.Config.BaseURL.String())
+ assert.Equal(t, FakeAuthKey, client.Config.AuthToken)
}
diff --git a/whisk/info.go b/whisk/info.go
index 73ca16c..939412f 100644
--- a/whisk/info.go
+++ b/whisk/info.go
@@ -18,56 +18,56 @@
package whisk
import (
- "net/http"
- "net/url"
- "errors"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
- "fmt"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "net/http"
+ "net/url"
)
type Info struct {
- Whisk string `json:"whisk,omitempty"`
- Version string `json:"version,omitempty"`
- Build string `json:"build,omitempty"`
- BuildNo string `json:"buildno,omitempty"`
+ Whisk string `json:"whisk,omitempty"`
+ Version string `json:"version,omitempty"`
+ Build string `json:"build,omitempty"`
+ BuildNo string `json:"buildno,omitempty"`
}
type InfoService struct {
- client *Client
+ client *Client
}
func (s *InfoService) Get() (*Info, *http.Response, error) {
- // make a request to c.BaseURL / v1
- err := s.client.LoadX509KeyPair()
- if err != nil {
- return nil, nil, err
- }
- urlStr := fmt.Sprintf("%s/%s", s.client.BaseURL.String(), s.client.Config.Version)
- u, err := url.Parse(urlStr)
- if err != nil {
- Debug(DbgError, "url.Parse(%s) error: %s\n", urlStr, err)
- errStr := wski18n.T("Unable to URL parse '{{.version}}': {{.err}}",
- map[string]interface{}{"version": urlStr, "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
+ // make a request to c.BaseURL / v1
+ err := s.client.LoadX509KeyPair()
+ if err != nil {
+ return nil, nil, err
+ }
+ urlStr := fmt.Sprintf("%s/%s", s.client.BaseURL.String(), s.client.Config.Version)
+ u, err := url.Parse(urlStr)
+ if err != nil {
+ Debug(DbgError, "url.Parse(%s) error: %s\n", urlStr, err)
+ errStr := wski18n.T("Unable to URL parse '{{.version}}': {{.err}}",
+ map[string]interface{}{"version": urlStr, "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
- req, err := http.NewRequest("GET", u.String(), nil)
- if err != nil {
- Debug(DbgError, "http.NewRequest(GET, %s) error: %s\n", u.String(), err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.url}}': {{.err}}",
- map[string]interface{}{"url": u.String(), "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
+ req, err := http.NewRequest("GET", u.String(), nil)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(GET, %s) error: %s\n", u.String(), err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.url}}': {{.err}}",
+ map[string]interface{}{"url": u.String(), "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
- Debug(DbgInfo, "Sending HTTP URL '%s'; req %#v\n", req.URL.String(), req)
- info := new(Info)
- resp, err := s.client.Do(req, &info, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, nil, err
- }
+ Debug(DbgInfo, "Sending HTTP URL '%s'; req %#v\n", req.URL.String(), req)
+ info := new(Info)
+ resp, err := s.client.Do(req, &info, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, nil, err
+ }
- return info, resp, nil
+ return info, resp, nil
}
diff --git a/whisk/namespace.go b/whisk/namespace.go
index 03b77c0..0371643 100644
--- a/whisk/namespace.go
+++ b/whisk/namespace.go
@@ -18,79 +18,79 @@
package whisk
import (
- "net/http"
- "errors"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
- "strings"
- "fmt"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "net/http"
+ "strings"
)
type Namespace struct {
- Name string `json:"name"`
+ Name string `json:"name"`
}
type NamespaceService struct {
- client *Client
+ client *Client
}
// Compare(sortable) compares namespace to sortable for the purpose of sorting.
// REQUIRED: sortable must also be of type Namespace.
// ***Method of type Sortable***
-func(namespace Namespace) Compare(sortable Sortable) (bool) {
- // Sorts alphabetically
- namespaceToCompare := sortable.(Namespace)
- var namespaceString string
- var compareString string
+func (namespace Namespace) Compare(sortable Sortable) bool {
+ // Sorts alphabetically
+ namespaceToCompare := sortable.(Namespace)
+ var namespaceString string
+ var compareString string
- namespaceString = strings.ToLower(namespace.Name)
- compareString = strings.ToLower(namespaceToCompare.Name)
+ namespaceString = strings.ToLower(namespace.Name)
+ compareString = strings.ToLower(namespaceToCompare.Name)
- return namespaceString < compareString
+ return namespaceString < compareString
}
// ToHeaderString() returns the header for a list of namespaces
-func(namespace Namespace) ToHeaderString() string {
- return fmt.Sprintf("%s\n", "namespaces")
+func (namespace Namespace) ToHeaderString() string {
+ return fmt.Sprintf("%s\n", "namespaces")
}
// ToSummaryRowString() returns a compound string of required parameters for printing
// from CLI command `wsk namespace list`.
// ***Method of type Sortable***
-func(namespace Namespace) ToSummaryRowString() string {
- return fmt.Sprintf("%s\n", namespace.Name)
+func (namespace Namespace) ToSummaryRowString() string {
+ return fmt.Sprintf("%s\n", namespace.Name)
}
// get a list of available namespaces
func (s *NamespaceService) List() ([]Namespace, *http.Response, error) {
- // make a request to c.BaseURL / namespaces
+ // make a request to c.BaseURL / namespaces
- // Create the request against the namespaces resource
- s.client.Config.Namespace = ""
- route := ""
- req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "s.client.NewRequest(GET) error: %s\n", err)
- errStr := wski18n.T("Unable to create HTTP request for GET: {{.err}}",
- map[string]interface{}{"err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
+ // Create the request against the namespaces resource
+ s.client.Config.Namespace = ""
+ route := ""
+ req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "s.client.NewRequest(GET) error: %s\n", err)
+ errStr := wski18n.T("Unable to create HTTP request for GET: {{.err}}",
+ map[string]interface{}{"err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
- var namespaceNames []string
- resp, err := s.client.Do(req, &namespaceNames, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
+ var namespaceNames []string
+ resp, err := s.client.Do(req, &namespaceNames, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
- var namespaces []Namespace
- for _, nsName := range namespaceNames {
- ns := Namespace{
- Name: nsName,
- }
- namespaces = append(namespaces, ns)
- }
+ var namespaces []Namespace
+ for _, nsName := range namespaceNames {
+ ns := Namespace{
+ Name: nsName,
+ }
+ namespaces = append(namespaces, ns)
+ }
- Debug(DbgInfo, "Returning []namespaces: %#v\n", namespaces)
- return namespaces, resp, nil
+ Debug(DbgInfo, "Returning []namespaces: %#v\n", namespaces)
+ return namespaces, resp, nil
}
diff --git a/whisk/package.go b/whisk/package.go
index 8597f15..898c3c5 100644
--- a/whisk/package.go
+++ b/whisk/package.go
@@ -18,234 +18,235 @@
package whisk
import (
- "fmt"
- "net/http"
- "net/url"
- "errors"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
- "strings"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "net/http"
+ "net/url"
+ "strings"
)
type PackageService struct {
- client *Client
+ client *Client
}
type PackageInterface interface {
- GetName() string
+ GetName() string
}
// Use this struct to represent the package/binding sent from the Whisk server
// Binding is a bool ???MWD20160602 now seeing Binding as a struct???
type Package struct {
- Namespace string `json:"namespace,omitempty"`
- Name string `json:"name,omitempty"`
- Version string `json:"version,omitempty"`
- Publish *bool `json:"publish,omitempty"`
- Annotations KeyValueArr `json:"annotations,omitempty"`
- Parameters KeyValueArr `json:"parameters,omitempty"`
- Binding *Binding `json:"binding,omitempty"`
- Actions []Action `json:"actions,omitempty"`
- Feeds []Action `json:"feeds,omitempty"`
+ Namespace string `json:"namespace,omitempty"`
+ Name string `json:"name,omitempty"`
+ Version string `json:"version,omitempty"`
+ Publish *bool `json:"publish,omitempty"`
+ Annotations KeyValueArr `json:"annotations,omitempty"`
+ Parameters KeyValueArr `json:"parameters,omitempty"`
+ Binding *Binding `json:"binding,omitempty"`
+ Actions []Action `json:"actions,omitempty"`
+ Feeds []Action `json:"feeds,omitempty"`
}
func (p *Package) GetName() string {
- return p.Name
+ return p.Name
}
// Use this struct when creating a binding
// Publish is NOT optional; Binding is a namespace/name object, not a bool
type BindingPackage struct {
- Namespace string `json:"-"`
- Name string `json:"-"`
- Version string `json:"version,omitempty"`
- Publish *bool `json:"publish,omitempty"`
- Annotations KeyValueArr `json:"annotations,omitempty"`
- Parameters KeyValueArr `json:"parameters,omitempty"`
- Binding `json:"binding"`
+ Namespace string `json:"-"`
+ Name string `json:"-"`
+ Version string `json:"version,omitempty"`
+ Publish *bool `json:"publish,omitempty"`
+ Annotations KeyValueArr `json:"annotations,omitempty"`
+ Parameters KeyValueArr `json:"parameters,omitempty"`
+ Binding `json:"binding"`
}
+
func (p *BindingPackage) GetName() string {
- return p.Name
+ return p.Name
}
type Binding struct {
- Namespace string `json:"namespace,omitempty"`
- Name string `json:"name,omitempty"`
+ Namespace string `json:"namespace,omitempty"`
+ Name string `json:"name,omitempty"`
}
type BindingUpdates struct {
- Added []string `json:"added,omitempty"`
- Updated []string `json:"updated,omitempty"`
- Deleted []string `json:"deleted,omitempty"`
+ Added []string `json:"added,omitempty"`
+ Updated []string `json:"updated,omitempty"`
+ Deleted []string `json:"deleted,omitempty"`
}
type PackageListOptions struct {
- Public bool `url:"public,omitempty"`
- Limit int `url:"limit"`
- Skip int `url:"skip"`
- Since int `url:"since,omitempty"`
- Docs bool `url:"docs,omitempty"`
+ Public bool `url:"public,omitempty"`
+ Limit int `url:"limit"`
+ Skip int `url:"skip"`
+ Since int `url:"since,omitempty"`
+ Docs bool `url:"docs,omitempty"`
}
// Compare(sortable) compares xPackage to sortable for the purpose of sorting.
// REQUIRED: sortable must also be of type Package.
// ***Method of type Sortable***
-func(xPackage Package) Compare(sortable Sortable) (bool) {
- // Sorts alphabetically by NAMESPACE -> PACKAGE_NAME
- packageToCompare := sortable.(Package)
+func (xPackage Package) Compare(sortable Sortable) bool {
+ // Sorts alphabetically by NAMESPACE -> PACKAGE_NAME
+ packageToCompare := sortable.(Package)
- var packageString string
- var compareString string
+ var packageString string
+ var compareString string
- packageString = strings.ToLower(fmt.Sprintf("%s%s",xPackage.Namespace,
- xPackage.Name))
- compareString = strings.ToLower(fmt.Sprintf("%s%s", packageToCompare.Namespace,
- packageToCompare.Name))
+ packageString = strings.ToLower(fmt.Sprintf("%s%s", xPackage.Namespace,
+ xPackage.Name))
+ compareString = strings.ToLower(fmt.Sprintf("%s%s", packageToCompare.Namespace,
+ packageToCompare.Name))
- return packageString < compareString
+ return packageString < compareString
}
// ToHeaderString() returns the header for a list of actions
-func(pkg Package) ToHeaderString() string {
- return fmt.Sprintf("%s\n", "packages")
+func (pkg Package) ToHeaderString() string {
+ return fmt.Sprintf("%s\n", "packages")
}
// ToSummaryRowString() returns a compound string of required parameters for printing
// from CLI command `wsk package list`.
// ***Method of type Sortable***
-func(xPackage Package) ToSummaryRowString() string{
- publishState := wski18n.T("private")
+func (xPackage Package) ToSummaryRowString() string {
+ publishState := wski18n.T("private")
- if xPackage.Publish != nil && *xPackage.Publish {
- publishState = wski18n.T("shared")
- }
+ if xPackage.Publish != nil && *xPackage.Publish {
+ publishState = wski18n.T("shared")
+ }
- return fmt.Sprintf("%-70s %s\n", fmt.Sprintf("/%s/%s", xPackage.Namespace,
- xPackage.Name), publishState)
+ return fmt.Sprintf("%-70s %s\n", fmt.Sprintf("/%s/%s", xPackage.Namespace,
+ xPackage.Name), publishState)
}
func (s *PackageService) List(options *PackageListOptions) ([]Package, *http.Response, error) {
- route := fmt.Sprintf("packages")
- routeUrl, err := addRouteOptions(route, options)
- if err != nil {
- Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
- errStr := wski18n.T("Unable to build request URL: {{.err}}", map[string]interface{}{"err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create GET HTTP request for '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- var packages []Package
- resp, err := s.client.Do(req, &packages, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return packages, resp, err
+ route := fmt.Sprintf("packages")
+ routeUrl, err := addRouteOptions(route, options)
+ if err != nil {
+ Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
+ errStr := wski18n.T("Unable to build request URL: {{.err}}", map[string]interface{}{"err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create GET HTTP request for '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ var packages []Package
+ resp, err := s.client.Do(req, &packages, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return packages, resp, err
}
func (s *PackageService) Get(packageName string) (*Package, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- packageName = (&url.URL{Path: packageName}).String()
- route := fmt.Sprintf("packages/%s", packageName)
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ packageName = (&url.URL{Path: packageName}).String()
+ route := fmt.Sprintf("packages/%s", packageName)
- req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(GET, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create GET HTTP request for '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
+ req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(GET, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create GET HTTP request for '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
- p := new(Package)
- resp, err := s.client.Do(req, &p, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
+ p := new(Package)
+ resp, err := s.client.Do(req, &p, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
- return p, resp, nil
+ return p, resp, nil
}
func (s *PackageService) Insert(x_package PackageInterface, overwrite bool) (*Package, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- packageName := (&url.URL{Path: x_package.GetName()}).String()
- route := fmt.Sprintf("packages/%s?overwrite=%t", packageName, overwrite)
-
- req, err := s.client.NewRequest("PUT", route, x_package, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(PUT, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create PUT HTTP request for '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- p := new(Package)
- resp, err := s.client.Do(req, &p, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return p, resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ packageName := (&url.URL{Path: x_package.GetName()}).String()
+ route := fmt.Sprintf("packages/%s?overwrite=%t", packageName, overwrite)
+
+ req, err := s.client.NewRequest("PUT", route, x_package, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(PUT, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create PUT HTTP request for '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ p := new(Package)
+ resp, err := s.client.Do(req, &p, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return p, resp, nil
}
func (s *PackageService) Delete(packageName string) (*http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- packageName = (&url.URL{Path: packageName}).String()
- route := fmt.Sprintf("packages/%s", packageName)
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ packageName = (&url.URL{Path: packageName}).String()
+ route := fmt.Sprintf("packages/%s", packageName)
- req, err := s.client.NewRequest("DELETE", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(DELETE, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create DELETE HTTP request for '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
+ req, err := s.client.NewRequest("DELETE", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(DELETE, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create DELETE HTTP request for '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
- resp, err := s.client.Do(req, nil, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return resp, err
- }
+ resp, err := s.client.Do(req, nil, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return resp, err
+ }
- return resp, nil
+ return resp, nil
}
func (s *PackageService) Refresh() (*BindingUpdates, *http.Response, error) {
- route := "packages/refresh"
-
- req, err := s.client.NewRequest("POST", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(POST, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create POST HTTP request for '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- updates := &BindingUpdates{}
- resp, err := s.client.Do(req, updates, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return updates, resp, nil
+ route := "packages/refresh"
+
+ req, err := s.client.NewRequest("POST", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(POST, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create POST HTTP request for '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ updates := &BindingUpdates{}
+ resp, err := s.client.Do(req, updates, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return updates, resp, nil
}
diff --git a/whisk/rule.go b/whisk/rule.go
index 86261ad..624d66c 100644
--- a/whisk/rule.go
+++ b/whisk/rule.go
@@ -18,200 +18,200 @@
package whisk
import (
- "fmt"
- "net/http"
- "strings"
- "errors"
- "net/url"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "net/http"
+ "net/url"
+ "strings"
)
type RuleService struct {
- client *Client
+ client *Client
}
type Rule struct {
- Namespace string `json:"namespace,omitempty"`
- Name string `json:"name,omitempty"`
- Version string `json:"version,omitempty"`
- Status string `json:"status"`
- Trigger interface{} `json:"trigger"`
- Action interface{} `json:"action"`
- Publish *bool `json:"publish,omitempty"`
+ Namespace string `json:"namespace,omitempty"`
+ Name string `json:"name,omitempty"`
+ Version string `json:"version,omitempty"`
+ Status string `json:"status"`
+ Trigger interface{} `json:"trigger"`
+ Action interface{} `json:"action"`
+ Publish *bool `json:"publish,omitempty"`
}
type RuleListOptions struct {
- Limit int `url:"limit"`
- Skip int `url:"skip"`
- Docs bool `url:"docs,omitempty"`
+ Limit int `url:"limit"`
+ Skip int `url:"skip"`
+ Docs bool `url:"docs,omitempty"`
}
// Compare(sortable) compares rule to sortable for the purpose of sorting.
// REQUIRED: sortable must also be of type Rule.
// ***Method of type Sortable***
-func(rule Rule) Compare(sortable Sortable) (bool) {
- // Sorts alphabetically by NAMESPACE -> PACKAGE_NAME
- ruleToCompare := sortable.(Rule)
- var ruleString string
- var compareString string
+func (rule Rule) Compare(sortable Sortable) bool {
+ // Sorts alphabetically by NAMESPACE -> PACKAGE_NAME
+ ruleToCompare := sortable.(Rule)
+ var ruleString string
+ var compareString string
- ruleString = strings.ToLower(fmt.Sprintf("%s%s",rule.Namespace, rule.Name))
- compareString = strings.ToLower(fmt.Sprintf("%s%s", ruleToCompare.Namespace,
- ruleToCompare.Name))
+ ruleString = strings.ToLower(fmt.Sprintf("%s%s", rule.Namespace, rule.Name))
+ compareString = strings.ToLower(fmt.Sprintf("%s%s", ruleToCompare.Namespace,
+ ruleToCompare.Name))
- return ruleString < compareString
+ return ruleString < compareString
}
// ToHeaderString() returns the header for a list of rules
-func(rule Rule) ToHeaderString() string {
- return fmt.Sprintf("%s\n", "rules")
+func (rule Rule) ToHeaderString() string {
+ return fmt.Sprintf("%s\n", "rules")
}
// ToSummaryRowString() returns a compound string of required parameters for printing
// from CLI command `wsk rule list`.
// ***Method of type Sortable***
-func(rule Rule) ToSummaryRowString() string{
- publishState := wski18n.T("private")
+func (rule Rule) ToSummaryRowString() string {
+ publishState := wski18n.T("private")
- return fmt.Sprintf("%-70s %-20s %s\n", fmt.Sprintf("/%s/%s", rule.Namespace,
- rule.Name), publishState, rule.Status)
+ return fmt.Sprintf("%-70s %-20s %s\n", fmt.Sprintf("/%s/%s", rule.Namespace,
+ rule.Name), publishState, rule.Status)
}
func (s *RuleService) List(options *RuleListOptions) ([]Rule, *http.Response, error) {
- route := "rules"
- routeUrl, err := addRouteOptions(route, options)
- if err != nil {
- Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
- errStr := wski18n.T("Unable to append options '{{.options}}' to URL route '{{.route}}': {{.err}}",
- map[string]interface{}{"options": fmt.Sprintf("%#v", options), "route": route, "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- var rules []Rule
- resp, err := s.client.Do(req, &rules, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return rules, resp, err
+ route := "rules"
+ routeUrl, err := addRouteOptions(route, options)
+ if err != nil {
+ Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
+ errStr := wski18n.T("Unable to append options '{{.options}}' to URL route '{{.route}}': {{.err}}",
+ map[string]interface{}{"options": fmt.Sprintf("%#v", options), "route": route, "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ var rules []Rule
+ resp, err := s.client.Do(req, &rules, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return rules, resp, err
}
func (s *RuleService) Insert(rule *Rule, overwrite bool) (*Rule, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- ruleName := (&url.URL{Path: rule.Name}).String()
- route := fmt.Sprintf("rules/%s?overwrite=%t", ruleName, overwrite)
-
- req, err := s.client.NewRequest("PUT", route, rule, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(PUT, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for PUT '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- r := new(Rule)
- resp, err := s.client.Do(req, &r, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return r, resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ ruleName := (&url.URL{Path: rule.Name}).String()
+ route := fmt.Sprintf("rules/%s?overwrite=%t", ruleName, overwrite)
+
+ req, err := s.client.NewRequest("PUT", route, rule, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(PUT, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for PUT '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ r := new(Rule)
+ resp, err := s.client.Do(req, &r, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return r, resp, nil
}
func (s *RuleService) Get(ruleName string) (*Rule, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- ruleName = (&url.URL{Path: ruleName}).String()
- route := fmt.Sprintf("rules/%s", ruleName)
-
- req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(GET, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- r := new(Rule)
- resp, err := s.client.Do(req, &r, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return r, resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ ruleName = (&url.URL{Path: ruleName}).String()
+ route := fmt.Sprintf("rules/%s", ruleName)
+
+ req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(GET, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ r := new(Rule)
+ resp, err := s.client.Do(req, &r, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return r, resp, nil
}
func (s *RuleService) Delete(ruleName string) (*http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- ruleName = (&url.URL{Path: ruleName}).String()
- route := fmt.Sprintf("rules/%s", ruleName)
-
- req, err := s.client.NewRequest("DELETE", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(DELETE, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for DELETE '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
-
- resp, err := s.client.Do(req, nil, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return resp, err
- }
-
- return resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ ruleName = (&url.URL{Path: ruleName}).String()
+ route := fmt.Sprintf("rules/%s", ruleName)
+
+ req, err := s.client.NewRequest("DELETE", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(DELETE, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for DELETE '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
+
+ resp, err := s.client.Do(req, nil, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return resp, err
+ }
+
+ return resp, nil
}
func (s *RuleService) SetState(ruleName string, state string) (*Rule, *http.Response, error) {
- state = strings.ToLower(state)
- if state != "active" && state != "inactive" {
- errStr := wski18n.T("Internal error. Invalid state option '{{.state}}'. Valid options are \"active\" and \"inactive\".",
- map[string]interface{}{"state": state})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- ruleName = (&url.URL{Path: ruleName}).String()
- route := fmt.Sprintf("rules/%s", ruleName)
-
- ruleState := &Rule{ Status: state }
-
- req, err := s.client.NewRequest("POST", route, ruleState, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(POST, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for POST '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- r := new(Rule)
- resp, err := s.client.Do(req, &r, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return r, resp, nil
+ state = strings.ToLower(state)
+ if state != "active" && state != "inactive" {
+ errStr := wski18n.T("Internal error. Invalid state option '{{.state}}'. Valid options are \"active\" and \"inactive\".",
+ map[string]interface{}{"state": state})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ ruleName = (&url.URL{Path: ruleName}).String()
+ route := fmt.Sprintf("rules/%s", ruleName)
+
+ ruleState := &Rule{Status: state}
+
+ req, err := s.client.NewRequest("POST", route, ruleState, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(POST, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for POST '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ r := new(Rule)
+ resp, err := s.client.Do(req, &r, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return r, resp, nil
}
diff --git a/whisk/sdk.go b/whisk/sdk.go
index 38687d2..06743b1 100644
--- a/whisk/sdk.go
+++ b/whisk/sdk.go
@@ -18,65 +18,65 @@
package whisk
import (
- "fmt"
- "errors"
- "net/http"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "net/http"
)
type SdkService struct {
- client *Client
+ client *Client
}
// Structure for SDK request responses
type Sdk struct {
- // TODO :: Add SDK fields
+ // TODO :: Add SDK fields
}
type SdkRequest struct {
- // TODO :: Add SDK
+ // TODO :: Add SDK
}
// Install artifact {component = docker || swift || iOS}
func (s *SdkService) Install(relFileUrl string) (*http.Response, error) {
- err := s.client.LoadX509KeyPair()
- if err != nil {
- return nil, err
- }
- baseURL := s.client.Config.BaseURL
- // Remove everything but the scheme, host, and port
- baseURL.Path, baseURL.RawQuery, baseURL.Fragment = "", "", ""
+ err := s.client.LoadX509KeyPair()
+ if err != nil {
+ return nil, err
+ }
+ baseURL := s.client.Config.BaseURL
+ // Remove everything but the scheme, host, and port
+ baseURL.Path, baseURL.RawQuery, baseURL.Fragment = "", "", ""
- urlStr := fmt.Sprintf("%s/%s", baseURL, relFileUrl)
+ urlStr := fmt.Sprintf("%s/%s", baseURL, relFileUrl)
- req, err := http.NewRequest("GET", urlStr, nil)
- if err != nil {
- Debug(DbgError, "http.NewRequest(GET, %s, nil) error: %s\n", urlStr, err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.url}}': {{.err}}",
- map[string]interface{}{"url": urlStr, "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
+ req, err := http.NewRequest("GET", urlStr, nil)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(GET, %s, nil) error: %s\n", urlStr, err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.url}}': {{.err}}",
+ map[string]interface{}{"url": urlStr, "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
- if IsVerbose() {
- fmt.Println("REQUEST:")
- fmt.Printf("[%s]\t%s\n", req.Method, req.URL)
- if len(req.Header) > 0 {
- fmt.Println("Req Headers")
- PrintJSON(req.Header)
- }
- if req.Body != nil {
- fmt.Println("Req Body")
- fmt.Println(req.Body)
- }
- }
+ if IsVerbose() {
+ fmt.Println("REQUEST:")
+ fmt.Printf("[%s]\t%s\n", req.Method, req.URL)
+ if len(req.Header) > 0 {
+ fmt.Println("Req Headers")
+ PrintJSON(req.Header)
+ }
+ if req.Body != nil {
+ fmt.Println("Req Body")
+ fmt.Println(req.Body)
+ }
+ }
- // Directly use the HTTP client, not the Whisk CLI client, so that the response body is left alone
- resp, err := s.client.client.Do(req)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return resp, err
- }
+ // Directly use the HTTP client, not the Whisk CLI client, so that the response body is left alone
+ resp, err := s.client.client.Do(req)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return resp, err
+ }
- return resp, nil
+ return resp, nil
}
diff --git a/whisk/shared.go b/whisk/shared.go
index 5b81f91..53d8ce5 100644
--- a/whisk/shared.go
+++ b/whisk/shared.go
@@ -18,13 +18,13 @@
package whisk
import (
- "encoding/json"
- "strings"
+ "encoding/json"
+ "strings"
)
type KeyValue struct {
- Key string `json:"key"`
- Value interface{} `json:"value"`
+ Key string `json:"key"`
+ Value interface{} `json:"value"`
}
type KeyValueArr []KeyValue
@@ -32,41 +32,41 @@ type KeyValueArr []KeyValue
/*
Retrieves a value associated with a given key from a KeyValueArr. A key of type string must be passed to the method.
An interface will be returned containing the found value. If a key could not be found, a nil value will be returned.
- */
+*/
func (keyValueArr KeyValueArr) GetValue(key string) (res interface{}) {
- for i := 0; i < len(keyValueArr); i++ {
- if keyValueArr[i].Key == key {
- res = keyValueArr[i].Value
- break;
- }
- }
+ for i := 0; i < len(keyValueArr); i++ {
+ if keyValueArr[i].Key == key {
+ res = keyValueArr[i].Value
+ break
+ }
+ }
- Debug(DbgInfo, "Got value '%v' for key '%s' from '%v'\n", res, key, keyValueArr)
+ Debug(DbgInfo, "Got value '%v' for key '%s' from '%v'\n", res, key, keyValueArr)
- return res
+ return res
}
-func (keyValueArr KeyValueArr) FindKeyValue(key string) (int) {
- for i := 0; i < len(keyValueArr); i++ {
- if strings.ToLower(keyValueArr[i].Key) == strings.ToLower(key) {
- return i
- }
- }
+func (keyValueArr KeyValueArr) FindKeyValue(key string) int {
+ for i := 0; i < len(keyValueArr); i++ {
+ if strings.ToLower(keyValueArr[i].Key) == strings.ToLower(key) {
+ return i
+ }
+ }
- return -1
+ return -1
}
/*
Appends items from appKeyValueArr to keyValueArr if the appKeyValueArr item does not exist in keyValueArr.
- */
-func (keyValueArr KeyValueArr) AppendKeyValueArr(appKeyValueArr KeyValueArr) (KeyValueArr) {
- for i := 0; i < len(appKeyValueArr); i++ {
- if KeyValueArr.FindKeyValue(keyValueArr, appKeyValueArr[i].Key) == -1 {
- keyValueArr = append(keyValueArr, appKeyValueArr[i])
- }
- }
+*/
+func (keyValueArr KeyValueArr) AppendKeyValueArr(appKeyValueArr KeyValueArr) KeyValueArr {
+ for i := 0; i < len(appKeyValueArr); i++ {
+ if KeyValueArr.FindKeyValue(keyValueArr, appKeyValueArr[i].Key) == -1 {
+ keyValueArr = append(keyValueArr, appKeyValueArr[i])
+ }
+ }
- return keyValueArr
+ return keyValueArr
}
type Annotations []map[string]interface{}
@@ -74,7 +74,7 @@ type Annotations []map[string]interface{}
type Parameters *json.RawMessage
type Limits struct {
- Timeout *int `json:"timeout,omitempty"`
- Memory *int `json:"memory,omitempty"`
- Logsize *int `json:"logs,omitempty"`
+ Timeout *int `json:"timeout,omitempty"`
+ Memory *int `json:"memory,omitempty"`
+ Logsize *int `json:"logs,omitempty"`
}
diff --git a/whisk/trace.go b/whisk/trace.go
index e3ba7e2..86dc76d 100644
--- a/whisk/trace.go
+++ b/whisk/trace.go
@@ -18,18 +18,19 @@
package whisk
import (
- "fmt"
- "runtime"
- "strings"
- "os"
+ "fmt"
+ "os"
+ "runtime"
+ "strings"
)
type DebugLevel string
+
const (
- DbgInfo DebugLevel = "Inf"
- DbgWarn DebugLevel = "Wrn"
- DbgError DebugLevel = "Err"
- DbgFatal DebugLevel = "Ftl"
+ DbgInfo DebugLevel = "Inf"
+ DbgWarn DebugLevel = "Wrn"
+ DbgError DebugLevel = "Err"
+ DbgFatal DebugLevel = "Ftl"
)
const MaxNameLen int = 25
@@ -38,58 +39,58 @@ var isVerbose bool
var isDebug bool
func init() {
- if len(os.Getenv("WSK_CLI_DEBUG")) > 0 { // Useful for tracing init() code, before parms are parsed
- SetDebug(true)
- }
+ if len(os.Getenv("WSK_CLI_DEBUG")) > 0 { // Useful for tracing init() code, before parms are parsed
+ SetDebug(true)
+ }
}
func SetDebug(b bool) {
- isDebug = b
+ isDebug = b
}
-func SetVerbose (b bool) {
- isVerbose = b
+func SetVerbose(b bool) {
+ isVerbose = b
}
func IsVerbose() bool {
- return isVerbose || isDebug
+ return isVerbose || isDebug
}
func IsDebug() bool {
- return isDebug
+ return isDebug
}
/* Function for tracing debug level messages to stdout
Output format:
[file-or-function-name]:line-#:[DebugLevel] The formated message without any appended \n
- */
+*/
func Debug(dl DebugLevel, msgFormat string, args ...interface{}) {
- if isDebug {
- pc, file, line, _ := runtime.Caller(1)
- fcn := runtime.FuncForPC(pc)
- msg := fmt.Sprintf(msgFormat, args...)
- fcnName := fcn.Name()
+ if isDebug {
+ pc, file, line, _ := runtime.Caller(1)
+ fcn := runtime.FuncForPC(pc)
+ msg := fmt.Sprintf(msgFormat, args...)
+ fcnName := fcn.Name()
- // Cobra command Run/RunE functions are anonymous, so the function name is unfriendly;
- // use the file name instead
- if strings.Contains(fcnName, "commands.glob.") || strings.Contains(fcnName, "whisk.glob.") {
- fcnName = file
- }
+ // Cobra command Run/RunE functions are anonymous, so the function name is unfriendly;
+ // use the file name instead
+ if strings.Contains(fcnName, "commands.glob.") || strings.Contains(fcnName, "whisk.glob.") {
+ fcnName = file
+ }
- // Only interested in the the trailing function/file name characters
- if len(fcnName) > MaxNameLen {
- fcnName = fcnName[len(fcnName)-MaxNameLen:]
- }
- fmt.Printf("[%-25s]:%03d:[%3s] %v", fcnName, line, dl, msg)
- }
+ // Only interested in the the trailing function/file name characters
+ if len(fcnName) > MaxNameLen {
+ fcnName = fcnName[len(fcnName)-MaxNameLen:]
+ }
+ fmt.Printf("[%-25s]:%03d:[%3s] %v", fcnName, line, dl, msg)
+ }
}
/* Function for tracing debug level messages to stdout
Output format:
[file-or-function-name]:line-#:[DebugLevel] The formatted message without any appended newline characters
- */
+*/
func Verbose(msgFormat string, args ...interface{}) {
- if IsVerbose() {
- msg := fmt.Sprintf(msgFormat, args...)
- fmt.Printf("%v", msg)
- }
+ if IsVerbose() {
+ msg := fmt.Sprintf(msgFormat, args...)
+ fmt.Printf("%v", msg)
+ }
}
diff --git a/whisk/trigger.go b/whisk/trigger.go
index 5bc6b12..63d456f 100644
--- a/whisk/trigger.go
+++ b/whisk/trigger.go
@@ -18,204 +18,204 @@
package whisk
import (
- "fmt"
- "net/http"
- "errors"
- "net/url"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
- "strings"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "net/http"
+ "net/url"
+ "strings"
)
type TriggerService struct {
- client *Client
+ client *Client
}
type Trigger struct {
- Namespace string `json:"namespace,omitempty"`
- Name string `json:"name,omityempty"`
- Version string `json:"version,omitempty"`
- ActivationId string `json:"activationId,omitempty"`
- Annotations KeyValueArr `json:"annotations,omitempty"`
- Parameters KeyValueArr `json:"parameters,omitempty"`
- Limits *Limits `json:"limits,omitempty"`
- Publish *bool `json:"publish,omitempty"`
+ Namespace string `json:"namespace,omitempty"`
+ Name string `json:"name,omityempty"`
+ Version string `json:"version,omitempty"`
+ ActivationId string `json:"activationId,omitempty"`
+ Annotations KeyValueArr `json:"annotations,omitempty"`
+ Parameters KeyValueArr `json:"parameters,omitempty"`
+ Limits *Limits `json:"limits,omitempty"`
+ Publish *bool `json:"publish,omitempty"`
}
type TriggerListOptions struct {
- Limit int `url:"limit"`
- Skip int `url:"skip"`
- Docs bool `url:"docs,omitempty"`
+ Limit int `url:"limit"`
+ Skip int `url:"skip"`
+ Docs bool `url:"docs,omitempty"`
}
// Compare(sortable) compares trigger to sortable for the purpose of sorting.
// REQUIRED: sortable must also be of type Trigger.
// ***Method of type Sortable***
-func(trigger Trigger) Compare(sortable Sortable) (bool) {
- // Sorts alphabetically by NAMESPACE -> TRIGGER_NAME
- triggerToCompare := sortable.(Trigger)
- var triggerString string
- var compareString string
-
- triggerString = strings.ToLower(fmt.Sprintf("%s%s",trigger.Namespace,
- trigger.Name))
- compareString = strings.ToLower(fmt.Sprintf("%s%s", triggerToCompare.Namespace,
- triggerToCompare.Name))
-
- return triggerString < compareString
+func (trigger Trigger) Compare(sortable Sortable) bool {
+ // Sorts alphabetically by NAMESPACE -> TRIGGER_NAME
+ triggerToCompare := sortable.(Trigger)
+ var triggerString string
+ var compareString string
+
+ triggerString = strings.ToLower(fmt.Sprintf("%s%s", trigger.Namespace,
+ trigger.Name))
+ compareString = strings.ToLower(fmt.Sprintf("%s%s", triggerToCompare.Namespace,
+ triggerToCompare.Name))
+
+ return triggerString < compareString
}
// ToHeaderString() returns the header for a list of triggers
-func(trigger Trigger) ToHeaderString() string {
- return fmt.Sprintf("%s\n", "triggers")
+func (trigger Trigger) ToHeaderString() string {
+ return fmt.Sprintf("%s\n", "triggers")
}
// ToSummaryRowString() returns a compound string of required parameters for printing
// from CLI command `wsk trigger list`.
// ***Method of type Sortable***
-func(trigger Trigger) ToSummaryRowString() string {
- publishState := wski18n.T("private")
+func (trigger Trigger) ToSummaryRowString() string {
+ publishState := wski18n.T("private")
- return fmt.Sprintf("%-70s %s\n", fmt.Sprintf("/%s/%s", trigger.Namespace,
- trigger.Name), publishState)
+ return fmt.Sprintf("%-70s %s\n", fmt.Sprintf("/%s/%s", trigger.Namespace,
+ trigger.Name), publishState)
}
func (s *TriggerService) List(options *TriggerListOptions) ([]Trigger, *http.Response, error) {
- route := "triggers"
- routeUrl, err := addRouteOptions(route, options)
- if err != nil {
- Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
- errStr := wski18n.T("Unable to append options '{{.options}}' to URL route '{{.route}}': {{.err}}",
- map[string]interface{}{"options": fmt.Sprintf("%#v", options), "route": route, "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- var triggers []Trigger
- resp, err := s.client.Do(req, &triggers, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return triggers, resp, nil
+ route := "triggers"
+ routeUrl, err := addRouteOptions(route, options)
+ if err != nil {
+ Debug(DbgError, "addRouteOptions(%s, %#v) error: '%s'\n", route, options, err)
+ errStr := wski18n.T("Unable to append options '{{.options}}' to URL route '{{.route}}': {{.err}}",
+ map[string]interface{}{"options": fmt.Sprintf("%#v", options), "route": route, "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ req, err := s.client.NewRequestUrl("GET", routeUrl, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(GET, %s, nil, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ var triggers []Trigger
+ resp, err := s.client.Do(req, &triggers, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return triggers, resp, nil
}
func (s *TriggerService) Insert(trigger *Trigger, overwrite bool) (*Trigger, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- triggerName := (&url.URL{Path: trigger.Name}).String()
- route := fmt.Sprintf("triggers/%s?overwrite=%t", triggerName, overwrite)
-
- routeUrl, err := url.Parse(route)
- if err != nil {
- Debug(DbgError, "url.Parse(%s) error: %s\n", route, err)
- errStr := wski18n.T("Invalid request URL '{{.url}}': {{.err}}",
- map[string]interface{}{"url": route, "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- req, err := s.client.NewRequestUrl("PUT", routeUrl, trigger, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
- if err != nil {
- Debug(DbgError, "http.NewRequestUrl(PUT, %s, %+v, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired); error: '%s'\n", routeUrl, trigger, err)
- errStr := wski18n.T("Unable to create HTTP request for PUT '{{.route}}': {{.err}}",
- map[string]interface{}{"route": routeUrl, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- t := new(Trigger)
- resp, err := s.client.Do(req, &t, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return t, resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ triggerName := (&url.URL{Path: trigger.Name}).String()
+ route := fmt.Sprintf("triggers/%s?overwrite=%t", triggerName, overwrite)
+
+ routeUrl, err := url.Parse(route)
+ if err != nil {
+ Debug(DbgError, "url.Parse(%s) error: %s\n", route, err)
+ errStr := wski18n.T("Invalid request URL '{{.url}}': {{.err}}",
+ map[string]interface{}{"url": route, "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ req, err := s.client.NewRequestUrl("PUT", routeUrl, trigger, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired)
+ if err != nil {
+ Debug(DbgError, "http.NewRequestUrl(PUT, %s, %+v, IncludeNamespaceInUrl, AppendOpenWhiskPathPrefix, EncodeBodyAsJson, AuthRequired); error: '%s'\n", routeUrl, trigger, err)
+ errStr := wski18n.T("Unable to create HTTP request for PUT '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": routeUrl, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ t := new(Trigger)
+ resp, err := s.client.Do(req, &t, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return t, resp, nil
}
func (s *TriggerService) Get(triggerName string) (*Trigger, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- triggerName = (&url.URL{Path: triggerName}).String()
- route := fmt.Sprintf("triggers/%s", triggerName)
-
- req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(GET, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- t := new(Trigger)
- resp, err := s.client.Do(req, &t, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return t, resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ triggerName = (&url.URL{Path: triggerName}).String()
+ route := fmt.Sprintf("triggers/%s", triggerName)
+
+ req, err := s.client.NewRequest("GET", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(GET, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for GET '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ t := new(Trigger)
+ resp, err := s.client.Do(req, &t, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return t, resp, nil
}
func (s *TriggerService) Delete(triggerName string) (*Trigger, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- triggerName = (&url.URL{Path: triggerName}).String()
- route := fmt.Sprintf("triggers/%s", triggerName)
-
- req, err := s.client.NewRequest("DELETE", route, nil, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError, "http.NewRequest(DELETE, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for DELETE '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- t := new(Trigger)
- resp, err := s.client.Do(req, &t, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return t, resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ triggerName = (&url.URL{Path: triggerName}).String()
+ route := fmt.Sprintf("triggers/%s", triggerName)
+
+ req, err := s.client.NewRequest("DELETE", route, nil, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, "http.NewRequest(DELETE, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for DELETE '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ t := new(Trigger)
+ resp, err := s.client.Do(req, &t, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return t, resp, nil
}
func (s *TriggerService) Fire(triggerName string, payload interface{}) (*Trigger, *http.Response, error) {
- // Encode resource name as a path (with no query params) before inserting it into the URI
- // This way any '?' chars in the name won't be treated as the beginning of the query params
- triggerName = (&url.URL{Path: triggerName}).String()
- route := fmt.Sprintf("triggers/%s", triggerName)
-
- req, err := s.client.NewRequest("POST", route, payload, IncludeNamespaceInUrl)
- if err != nil {
- Debug(DbgError," http.NewRequest(POST, %s); error: '%s'\n", route, err)
- errStr := wski18n.T("Unable to create HTTP request for POST '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, nil, werr
- }
-
- t := new(Trigger)
- resp, err := s.client.Do(req, &t, ExitWithSuccessOnTimeout)
- if err != nil {
- Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
- return nil, resp, err
- }
-
- return t, resp, nil
+ // Encode resource name as a path (with no query params) before inserting it into the URI
+ // This way any '?' chars in the name won't be treated as the beginning of the query params
+ triggerName = (&url.URL{Path: triggerName}).String()
+ route := fmt.Sprintf("triggers/%s", triggerName)
+
+ req, err := s.client.NewRequest("POST", route, payload, IncludeNamespaceInUrl)
+ if err != nil {
+ Debug(DbgError, " http.NewRequest(POST, %s); error: '%s'\n", route, err)
+ errStr := wski18n.T("Unable to create HTTP request for POST '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskErrorFromWskError(errors.New(errStr), err, EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, nil, werr
+ }
+
+ t := new(Trigger)
+ resp, err := s.client.Do(req, &t, ExitWithSuccessOnTimeout)
+ if err != nil {
+ Debug(DbgError, "s.client.Do() error - HTTP req %s; error: '%s'\n", req.URL.String(), err)
+ return nil, resp, err
+ }
+
+ return t, resp, nil
}
diff --git a/whisk/util.go b/whisk/util.go
index 9e1087d..9c4b789 100644
--- a/whisk/util.go
+++ b/whisk/util.go
@@ -18,89 +18,89 @@
package whisk
import (
- "errors"
- "fmt"
- "net/url"
- "reflect"
- "strings"
+ "errors"
+ "fmt"
+ "net/url"
+ "reflect"
+ "strings"
- "github.com/fatih/color"
- "github.com/google/go-querystring/query"
- "github.com/hokaccha/go-prettyjson"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "github.com/fatih/color"
+ "github.com/google/go-querystring/query"
+ "github.com/hokaccha/go-prettyjson"
)
// Sortable items are anything that needs to be sorted for listing purposes.
type Sortable interface {
- // Compare(sortable) compares an two sortables and returns true
- // if the item calling the Compare method is less than toBeCompared.
- // Sorts alphabetically by default, can have other parameters to sort by
- // passed by sortByName.
- Compare(toBeCompared Sortable) (bool)
+ // Compare(sortable) compares an two sortables and returns true
+ // if the item calling the Compare method is less than toBeCompared.
+ // Sorts alphabetically by default, can have other parameters to sort by
+ // passed by sortByName.
+ Compare(toBeCompared Sortable) bool
}
// Printable items are anything that need to be printed for listing purposes.
type Printable interface {
- ToHeaderString() string // Prints header information of a Printable
- ToSummaryRowString() string // Prints summary info of one Printable
+ ToHeaderString() string // Prints header information of a Printable
+ ToSummaryRowString() string // Prints summary info of one Printable
}
// addOptions adds the parameters in opt as URL query parameters to s. opt
// must be a struct whose fields may contain "url" tags.
func addRouteOptions(route string, options interface{}) (*url.URL, error) {
- Debug(DbgInfo, "Adding options %+v to route '%s'\n", options, route)
- u, err := url.Parse(route)
- if err != nil {
- Debug(DbgError,"url.Parse(%s) error: %s\n", route, err)
- errStr := wski18n.T("Unable to parse URL '{{.route}}': {{.err}}",
- map[string]interface{}{"route": route, "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
+ Debug(DbgInfo, "Adding options %+v to route '%s'\n", options, route)
+ u, err := url.Parse(route)
+ if err != nil {
+ Debug(DbgError, "url.Parse(%s) error: %s\n", route, err)
+ errStr := wski18n.T("Unable to parse URL '{{.route}}': {{.err}}",
+ map[string]interface{}{"route": route, "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
- v := reflect.ValueOf(options)
- if v.Kind() == reflect.Ptr && v.IsNil() {
- return u, nil
- }
+ v := reflect.ValueOf(options)
+ if v.Kind() == reflect.Ptr && v.IsNil() {
+ return u, nil
+ }
- qs, err := query.Values(options)
- if err != nil {
- Debug(DbgError,"query.Values(%#v) error: %s\n", options, err)
- errStr := wski18n.T("Unable to process URL query options '{{.options}}': {{.err}}",
- map[string]interface{}{"options": fmt.Sprintf("%#v", options), "err": err})
- werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
- return nil, werr
- }
+ qs, err := query.Values(options)
+ if err != nil {
+ Debug(DbgError, "query.Values(%#v) error: %s\n", options, err)
+ errStr := wski18n.T("Unable to process URL query options '{{.options}}': {{.err}}",
+ map[string]interface{}{"options": fmt.Sprintf("%#v", options), "err": err})
+ werr := MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
+ return nil, werr
+ }
- u.RawQuery = qs.Encode()
- Debug(DbgInfo,"Returning route options '%s' from input struct %+v\n", u.String(), options)
- return u, nil
+ u.RawQuery = qs.Encode()
+ Debug(DbgInfo, "Returning route options '%s' from input struct %+v\n", u.String(), options)
+ return u, nil
}
func PrintJSON(v interface{}) {
- output, _ := prettyjson.Marshal(v)
- fmt.Fprintln(color.Output, string(output))
+ output, _ := prettyjson.Marshal(v)
+ fmt.Fprintln(color.Output, string(output))
}
-func GetURLBase(host string, path string) (*url.URL, error) {
- if len(host) == 0 {
- errMsg := wski18n.T("An API host must be provided.\n")
- whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_GENERAL,
- DISPLAY_MSG, DISPLAY_USAGE)
- return nil, whiskErr
- }
+func GetURLBase(host string, path string) (*url.URL, error) {
+ if len(host) == 0 {
+ errMsg := wski18n.T("An API host must be provided.\n")
+ whiskErr := MakeWskError(errors.New(errMsg), EXIT_CODE_ERR_GENERAL,
+ DISPLAY_MSG, DISPLAY_USAGE)
+ return nil, whiskErr
+ }
- if !strings.HasPrefix(host, "http") {
- host = "https://" + host
- }
+ if !strings.HasPrefix(host, "http") {
+ host = "https://" + host
+ }
- urlBase := fmt.Sprintf("%s%s", host, path)
- url, err := url.Parse(urlBase)
+ urlBase := fmt.Sprintf("%s%s", host, path)
+ url, err := url.Parse(urlBase)
- if len(url.Scheme) == 0 || len(url.Host) == 0 {
- urlBase = fmt.Sprintf("https://%s%s", host, path)
- url, err = url.Parse(urlBase)
- }
+ if len(url.Scheme) == 0 || len(url.Host) == 0 {
+ urlBase = fmt.Sprintf("https://%s%s", host, path)
+ url, err = url.Parse(urlBase)
+ }
- return url, err
+ return url, err
}
diff --git a/whisk/wskerror.go b/whisk/wskerror.go
index a8adcde..f88fdae 100644
--- a/whisk/wskerror.go
+++ b/whisk/wskerror.go
@@ -17,34 +17,34 @@
package whisk
-const EXIT_CODE_ERR_GENERAL int = 1
-const EXIT_CODE_ERR_USAGE int = 2
-const EXIT_CODE_ERR_NETWORK int = 3
-const EXIT_CODE_ERR_HTTP_RESP int = 4
-const NOT_ALLOWED int = 149
-const EXIT_CODE_TIMED_OUT int = 202
-const EXIT_CODE_NOT_FOUND int = 148
-
-const DISPLAY_MSG bool = true
-const NO_DISPLAY_MSG bool = false
-const DISPLAY_USAGE bool = true
-const NO_DISPLAY_USAGE bool = false
-const NO_MSG_DISPLAYED bool = false
-const DISPLAY_PREFIX bool = true
-const NO_DISPLAY_PREFIX bool = false
-const APPLICATION_ERR bool = true
-const NO_APPLICATION_ERR bool = false
-const TIMED_OUT bool = true
+const EXIT_CODE_ERR_GENERAL int = 1
+const EXIT_CODE_ERR_USAGE int = 2
+const EXIT_CODE_ERR_NETWORK int = 3
+const EXIT_CODE_ERR_HTTP_RESP int = 4
+const NOT_ALLOWED int = 149
+const EXIT_CODE_TIMED_OUT int = 202
+const EXIT_CODE_NOT_FOUND int = 148
+
+const DISPLAY_MSG bool = true
+const NO_DISPLAY_MSG bool = false
+const DISPLAY_USAGE bool = true
+const NO_DISPLAY_USAGE bool = false
+const NO_MSG_DISPLAYED bool = false
+const DISPLAY_PREFIX bool = true
+const NO_DISPLAY_PREFIX bool = false
+const APPLICATION_ERR bool = true
+const NO_APPLICATION_ERR bool = false
+const TIMED_OUT bool = true
type WskError struct {
- RootErr error // Parent error
- ExitCode int // Error code to be returned to the OS
- DisplayMsg bool // When true, the error message should be displayed to console
- MsgDisplayed bool // When true, the error message has already been displayed, don't display it again
- DisplayUsage bool // When true, the CLI usage should be displayed before exiting
- DisplayPrefix bool // When true, the CLI will prefix an error message with "error: "
- ApplicationError bool // When true, the error is a result of an application failure
- TimedOut bool // When True, the error is a result of a timeout
+ RootErr error // Parent error
+ ExitCode int // Error code to be returned to the OS
+ DisplayMsg bool // When true, the error message should be displayed to console
+ MsgDisplayed bool // When true, the error message has already been displayed, don't display it again
+ DisplayUsage bool // When true, the CLI usage should be displayed before exiting
+ DisplayPrefix bool // When true, the CLI will prefix an error message with "error: "
+ ApplicationError bool // When true, the error is a result of an application failure
+ TimedOut bool // When True, the error is a result of a timeout
}
/*
@@ -53,9 +53,9 @@ WskError's setting for DisplayPrefix.
Parameters:
err - WskError object used to display an error message from
- */
+*/
func (whiskError WskError) Error() string {
- return whiskError.RootErr.Error()
+ return whiskError.RootErr.Error()
}
/*
@@ -69,26 +69,38 @@ Parameters:
bool - DisplayPreview. If true, the error message will be prefixed with "error: "
bool - TimedOut. If true, the error is a result of a timeout
*/
-func MakeWskError (err error, exitCode int, flags ...bool ) (resWhiskError *WskError) {
- resWhiskError = &WskError{
- RootErr: err,
- ExitCode: exitCode,
- DisplayMsg: false,
- DisplayUsage: false,
- MsgDisplayed: false,
- DisplayPrefix: true,
- ApplicationError: false,
- TimedOut: false,
- }
-
- if len(flags) > 0 { resWhiskError.DisplayMsg = flags[0] }
- if len(flags) > 1 { resWhiskError.DisplayUsage = flags[1] }
- if len(flags) > 2 { resWhiskError.MsgDisplayed = flags[2] }
- if len(flags) > 3 { resWhiskError.DisplayPrefix = flags[3] }
- if len(flags) > 4 { resWhiskError.ApplicationError = flags[4] }
- if len(flags) > 5 { resWhiskError.TimedOut = flags[5] }
-
- return resWhiskError
+func MakeWskError(err error, exitCode int, flags ...bool) (resWhiskError *WskError) {
+ resWhiskError = &WskError{
+ RootErr: err,
+ ExitCode: exitCode,
+ DisplayMsg: false,
+ DisplayUsage: false,
+ MsgDisplayed: false,
+ DisplayPrefix: true,
+ ApplicationError: false,
+ TimedOut: false,
+ }
+
+ if len(flags) > 0 {
+ resWhiskError.DisplayMsg = flags[0]
+ }
+ if len(flags) > 1 {
+ resWhiskError.DisplayUsage = flags[1]
+ }
+ if len(flags) > 2 {
+ resWhiskError.MsgDisplayed = flags[2]
+ }
+ if len(flags) > 3 {
+ resWhiskError.DisplayPrefix = flags[3]
+ }
+ if len(flags) > 4 {
+ resWhiskError.ApplicationError = flags[4]
+ }
+ if len(flags) > 5 {
+ resWhiskError.TimedOut = flags[5]
+ }
+
+ return resWhiskError
}
/*
@@ -103,25 +115,25 @@ Parameters:
bool - ApplicationError. If true, the error is a result of an application error
bool - TimedOut. If true, the error resulted from a timeout
*/
-func MakeWskErrorFromWskError (baseError error, whiskError error, exitCode int, flags ...bool) (resWhiskError *WskError) {
+func MakeWskErrorFromWskError(baseError error, whiskError error, exitCode int, flags ...bool) (resWhiskError *WskError) {
- // Get the exit code, and flags from the existing Whisk error
- if whiskError != nil {
+ // Get the exit code, and flags from the existing Whisk error
+ if whiskError != nil {
- // Ensure the Whisk error is a pointer
- switch errorType := whiskError.(type) {
- case *WskError:
- resWhiskError = errorType
- case WskError:
- resWhiskError = &errorType
- }
+ // Ensure the Whisk error is a pointer
+ switch errorType := whiskError.(type) {
+ case *WskError:
+ resWhiskError = errorType
+ case WskError:
+ resWhiskError = &errorType
+ }
- if resWhiskError != nil {
- exitCode, flags = getWhiskErrorProperties(resWhiskError, flags...)
- }
- }
+ if resWhiskError != nil {
+ exitCode, flags = getWhiskErrorProperties(resWhiskError, flags...)
+ }
+ }
- return MakeWskError(baseError, exitCode, flags...)
+ return MakeWskError(baseError, exitCode, flags...)
}
/*
@@ -132,43 +144,43 @@ Parameters:
whiskError - WskError to examine.
flags - Boolean values that may override the WskError object's values for DisplayMsg, DisplayUsage,
MsgDisplayed, ApplicationError, TimedOut.
- */
+*/
func getWhiskErrorProperties(whiskError *WskError, flags ...bool) (int, []bool) {
- if len(flags) > 0 {
- flags[0] = whiskError.DisplayMsg
- } else {
- flags = append(flags, whiskError.DisplayMsg)
- }
-
- if len(flags) > 1 {
- flags[1] = whiskError.DisplayUsage || flags[1]
- } else {
- flags = append(flags, whiskError.DisplayUsage)
- }
-
- if len(flags) > 2 {
- flags[2] = whiskError.MsgDisplayed || flags[2]
- } else {
- flags = append(flags, whiskError.MsgDisplayed)
- }
-
- if len(flags) > 3 {
- flags[3] = whiskError.DisplayPrefix || flags[3]
- } else {
- flags = append(flags, whiskError.DisplayPrefix)
- }
-
- if len(flags) > 4 {
- flags[4] = whiskError.ApplicationError || flags[4]
- } else {
- flags = append(flags, whiskError.ApplicationError)
- }
-
- if len(flags) > 5 {
- flags[5] = whiskError.TimedOut || flags[5]
- } else {
- flags = append(flags, whiskError.TimedOut)
- }
-
- return whiskError.ExitCode, flags
+ if len(flags) > 0 {
+ flags[0] = whiskError.DisplayMsg
+ } else {
+ flags = append(flags, whiskError.DisplayMsg)
+ }
+
+ if len(flags) > 1 {
+ flags[1] = whiskError.DisplayUsage || flags[1]
+ } else {
+ flags = append(flags, whiskError.DisplayUsage)
+ }
+
+ if len(flags) > 2 {
+ flags[2] = whiskError.MsgDisplayed || flags[2]
+ } else {
+ flags = append(flags, whiskError.MsgDisplayed)
+ }
+
+ if len(flags) > 3 {
+ flags[3] = whiskError.DisplayPrefix || flags[3]
+ } else {
+ flags = append(flags, whiskError.DisplayPrefix)
+ }
+
+ if len(flags) > 4 {
+ flags[4] = whiskError.ApplicationError || flags[4]
+ } else {
+ flags = append(flags, whiskError.ApplicationError)
+ }
+
+ if len(flags) > 5 {
+ flags[5] = whiskError.TimedOut || flags[5]
+ } else {
+ flags = append(flags, whiskError.TimedOut)
+ }
+
+ return whiskError.ExitCode, flags
}
diff --git a/whisk/wskprops.go b/whisk/wskprops.go
index c607c55..c5f0d75 100644
--- a/whisk/wskprops.go
+++ b/whisk/wskprops.go
@@ -18,313 +18,313 @@
package whisk
import (
- "io/ioutil"
- "fmt"
- "net/url"
- "os"
- "strings"
- "bufio"
- "errors"
- "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "bufio"
+ "errors"
+ "fmt"
+ "github.com/apache/incubator-openwhisk-client-go/wski18n"
+ "io/ioutil"
+ "net/url"
+ "os"
+ "strings"
)
const (
- OPENWHISK_HOME = "OPENWHISK_HOME"
- HOMEPATH = "HOME"
- DEFAULT_LOCAL_CONFIG = ".wskprops"
- OPENWHISK_PROPERTIES = "whisk.properties"
- TEST_AUTH_FILE = "testing.auth"
- OPENWHISK_PRO= "whisk.api.host.proto"
- OPENWHISK_PORT= "whisk.api.host.port"
- OPENWHISK_HOST= "whisk.api.host.name"
- DEFAULT_VERSION = "v1"
- DEFAULT_NAMESPACE = "guest"
-
- NAMESPACE = "NAMESPACE"
- AUTH = "AUTH"
- APIGW_ACCESS_TOKEN = "APIGW_ACCESS_TOKEN"
- APIVERSION = "APIVERSION"
- KEY = "KEY"
- CERT = "CERT"
- APIHOST = "APIHOST"
-
- DEFAULT_SOURCE = "wsk props"
- WSKPROP = "wsk props"
- WHISK_PROPERTY = "whisk.properties"
+ OPENWHISK_HOME = "OPENWHISK_HOME"
+ HOMEPATH = "HOME"
+ DEFAULT_LOCAL_CONFIG = ".wskprops"
+ OPENWHISK_PROPERTIES = "whisk.properties"
+ TEST_AUTH_FILE = "testing.auth"
+ OPENWHISK_PRO = "whisk.api.host.proto"
+ OPENWHISK_PORT = "whisk.api.host.port"
+ OPENWHISK_HOST = "whisk.api.host.name"
+ DEFAULT_VERSION = "v1"
+ DEFAULT_NAMESPACE = "guest"
+
+ NAMESPACE = "NAMESPACE"
+ AUTH = "AUTH"
+ APIGW_ACCESS_TOKEN = "APIGW_ACCESS_TOKEN"
+ APIVERSION = "APIVERSION"
+ KEY = "KEY"
+ CERT = "CERT"
+ APIHOST = "APIHOST"
+
+ DEFAULT_SOURCE = "wsk props"
+ WSKPROP = "wsk props"
+ WHISK_PROPERTY = "whisk.properties"
)
type Wskprops struct {
- APIHost string
- AuthKey string
- Namespace string
- AuthAPIGWKey string
- APIGWSpaceSuid string
- Apiversion string
- Key string
- Cert string
- Source string
+ APIHost string
+ AuthKey string
+ Namespace string
+ AuthAPIGWKey string
+ APIGWSpaceSuid string
+ Apiversion string
+ Key string
+ Cert string
+ Source string
}
func GetUrlBase(host string) (*url.URL, error) {
- urlBase := fmt.Sprintf("%s/api", host)
- url, err := url.Parse(urlBase)
+ urlBase := fmt.Sprintf("%s/api", host)
+ url, err := url.Parse(urlBase)
- if len(url.Scheme) == 0 || len(url.Host) == 0 {
- urlBase = fmt.Sprintf("https://%s/api", host)
- url, err = url.Parse(urlBase)
- }
+ if len(url.Scheme) == 0 || len(url.Host) == 0 {
+ urlBase = fmt.Sprintf("https://%s/api", host)
+ url, err = url.Parse(urlBase)
+ }
- return url, err
+ return url, err
}
-func convertWskpropsToConfig(dep *Wskprops) (*Config) {
- var config Config
- config.Host = dep.APIHost
- if len(config.Host) != 0 {
- v, err := GetUrlBase(config.Host)
- if err == nil {
- config.BaseURL = v
- }
- }
- config.Namespace = dep.Namespace
- config.Cert = dep.Cert
- config.Key = dep.Key
- config.AuthToken = dep.AuthKey
-
- config.Version = dep.Apiversion
- config.Verbose = false
- config.Debug = false
- config.Insecure = true
-
- return &config
+func convertWskpropsToConfig(dep *Wskprops) *Config {
+ var config Config
+ config.Host = dep.APIHost
+ if len(config.Host) != 0 {
+ v, err := GetUrlBase(config.Host)
+ if err == nil {
+ config.BaseURL = v
+ }
+ }
+ config.Namespace = dep.Namespace
+ config.Cert = dep.Cert
+ config.Key = dep.Key
+ config.AuthToken = dep.AuthKey
+
+ config.Version = dep.Apiversion
+ config.Verbose = false
+ config.Debug = false
+ config.Insecure = true
+
+ return &config
}
func GetDefaultConfigFromProperties(pi Properties) (*Config, error) {
- var config *Config
- dep, e := GetDefaultWskProp(pi)
- config = convertWskpropsToConfig(dep)
- return config, e
+ var config *Config
+ dep, e := GetDefaultWskProp(pi)
+ config = convertWskpropsToConfig(dep)
+ return config, e
}
func GetConfigFromWhiskProperties(pi Properties) (*Config, error) {
- var config *Config
- dep, e := GetWskPropFromWhiskProperty(pi)
- config = convertWskpropsToConfig(dep)
- return config, e
+ var config *Config
+ dep, e := GetWskPropFromWhiskProperty(pi)
+ config = convertWskpropsToConfig(dep)
+ return config, e
}
func GetConfigFromWskprops(pi Properties, path string) (*Config, error) {
- var config *Config
- dep, e := GetWskPropFromWskprops(pi, path)
- config = convertWskpropsToConfig(dep)
- return config, e
+ var config *Config
+ dep, e := GetWskPropFromWskprops(pi, path)
+ config = convertWskpropsToConfig(dep)
+ return config, e
}
-var GetDefaultWskProp = func (pi Properties) (*Wskprops, error) {
- var dep *Wskprops
- dep = pi.GetPropsFromWskprops("")
- error := ValidateWskprops(dep)
- if error != nil {
- dep_whisk := pi.GetPropsFromWhiskProperties()
- error_whisk := ValidateWskprops(dep_whisk)
- if error_whisk != nil {
- return dep, error
- } else {
- return dep_whisk, error_whisk
- }
- }
- return dep, error
+var GetDefaultWskProp = func(pi Properties) (*Wskprops, error) {
+ var dep *Wskprops
+ dep = pi.GetPropsFromWskprops("")
+ error := ValidateWskprops(dep)
+ if error != nil {
+ dep_whisk := pi.GetPropsFromWhiskProperties()
+ error_whisk := ValidateWskprops(dep_whisk)
+ if error_whisk != nil {
+ return dep, error
+ } else {
+ return dep_whisk, error_whisk
+ }
+ }
+ return dep, error
}
-var GetWskPropFromWskprops = func (pi Properties, path string) (*Wskprops, error) {
- var dep *Wskprops
- dep = pi.GetPropsFromWskprops(path)
- error := ValidateWskprops(dep)
- return dep, error
+var GetWskPropFromWskprops = func(pi Properties, path string) (*Wskprops, error) {
+ var dep *Wskprops
+ dep = pi.GetPropsFromWskprops(path)
+ error := ValidateWskprops(dep)
+ return dep, error
}
-var GetWskPropFromWhiskProperty = func (pi Properties) (*Wskprops, error) {
- var dep *Wskprops
- dep = pi.GetPropsFromWhiskProperties()
- error := ValidateWskprops(dep)
- return dep, error
+var GetWskPropFromWhiskProperty = func(pi Properties) (*Wskprops, error) {
+ var dep *Wskprops
+ dep = pi.GetPropsFromWhiskProperties()
+ error := ValidateWskprops(dep)
+ return dep, error
}
type Properties interface {
- GetPropsFromWskprops(string) *Wskprops
- GetPropsFromWhiskProperties() *Wskprops
+ GetPropsFromWskprops(string) *Wskprops
+ GetPropsFromWhiskProperties() *Wskprops
}
type PropertiesImp struct {
- OsPackage OSPackage
+ OsPackage OSPackage
}
func (pi PropertiesImp) GetPropsFromWskprops(path string) *Wskprops {
- dep := GetDefaultWskprops(WSKPROP)
-
- var wskpropsPath string
- if path != "" {
- wskpropsPath = path
- } else {
- wskpropsPath = pi.OsPackage.Getenv(HOMEPATH, "") + "/" + DEFAULT_LOCAL_CONFIG
- }
- results, err := ReadProps(wskpropsPath)
-
- if err == nil {
-
- dep.APIHost = GetValue(results, APIHOST, dep.APIHost)
-
- dep.AuthKey = GetValue(results, AUTH, dep.AuthKey)
- dep.Namespace = GetValue(results, NAMESPACE, dep.Namespace)
- dep.AuthAPIGWKey = GetValue(results, APIGW_ACCESS_TOKEN, dep.AuthAPIGWKey)
- if len(dep.AuthKey) > 0 {
- dep.APIGWSpaceSuid = strings.Split(dep.AuthKey, ":")[0]
- }
- dep.Apiversion = GetValue(results, APIVERSION, dep.Apiversion)
- dep.Key = GetValue(results, KEY, dep.Key)
- dep.Cert = GetValue(results, CERT, dep.Cert)
- }
-
- return dep
+ dep := GetDefaultWskprops(WSKPROP)
+
+ var wskpropsPath string
+ if path != "" {
+ wskpropsPath = path
+ } else {
+ wskpropsPath = pi.OsPackage.Getenv(HOMEPATH, "") + "/" + DEFAULT_LOCAL_CONFIG
+ }
+ results, err := ReadProps(wskpropsPath)
+
+ if err == nil {
+
+ dep.APIHost = GetValue(results, APIHOST, dep.APIHost)
+
+ dep.AuthKey = GetValue(results, AUTH, dep.AuthKey)
+ dep.Namespace = GetValue(results, NAMESPACE, dep.Namespace)
+ dep.AuthAPIGWKey = GetValue(results, APIGW_ACCESS_TOKEN, dep.AuthAPIGWKey)
+ if len(dep.AuthKey) > 0 {
+ dep.APIGWSpaceSuid = strings.Split(dep.AuthKey, ":")[0]
+ }
+ dep.Apiversion = GetValue(results, APIVERSION, dep.Apiversion)
+ dep.Key = GetValue(results, KEY, dep.Key)
+ dep.Cert = GetValue(results, CERT, dep.Cert)
+ }
+
+ return dep
}
func (pi PropertiesImp) GetPropsFromWhiskProperties() *Wskprops {
- dep := GetDefaultWskprops(WHISK_PROPERTY)
- path := pi.OsPackage.Getenv(OPENWHISK_HOME, "") + "/" + OPENWHISK_PROPERTIES
- results, err := ReadProps(path)
-
- if err == nil {
- authPath := GetValue(results, TEST_AUTH_FILE, "")
- b, err := ioutil.ReadFile(authPath)
- if err == nil {
- dep.AuthKey = strings.TrimSpace(string(b))
- }
- dep.APIHost = GetValue(results, OPENWHISK_HOST, "")
- dep.Namespace = DEFAULT_NAMESPACE
- if len(dep.AuthKey) > 0 {
- dep.APIGWSpaceSuid = strings.Split(dep.AuthKey, ":")[0]
- }
- }
- return dep
+ dep := GetDefaultWskprops(WHISK_PROPERTY)
+ path := pi.OsPackage.Getenv(OPENWHISK_HOME, "") + "/" + OPENWHISK_PROPERTIES
+ results, err := ReadProps(path)
+
+ if err == nil {
+ authPath := GetValue(results, TEST_AUTH_FILE, "")
+ b, err := ioutil.ReadFile(authPath)
+ if err == nil {
+ dep.AuthKey = strings.TrimSpace(string(b))
+ }
+ dep.APIHost = GetValue(results, OPENWHISK_HOST, "")
+ dep.Namespace = DEFAULT_NAMESPACE
+ if len(dep.AuthKey) > 0 {
+ dep.APIGWSpaceSuid = strings.Split(dep.AuthKey, ":")[0]
+ }
+ }
+ return dep
}
-var ValidateWskprops = func (wskprops *Wskprops) error {
- // There are at least two fields: WHISKAPIURL and AuthKey, mandatory for a valid Wskprops.
- errStr := ""
- if (len(wskprops.APIHost) == 0) {
- if wskprops.Source == WHISK_PROPERTY {
- errStr = wski18n.T("OpenWhisk API host is missing (Please configure WHISK_APIHOST in .wskprops under the system HOME directory.)")
- } else {
- errStr = wski18n.T("OpenWhisk API host is missing (Please configure whisk.api.host.proto, whisk.api.host.name and whisk.api.host.port in whisk.properties under the OPENWHISK_HOME directory.)")
- }
- return MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, DISPLAY_USAGE)
- } else {
- if (len(wskprops.AuthKey) == 0) {
- if wskprops.Source == WHISK_PROPERTY {
- errStr = wski18n.T("Authentication key is missing (Please configure AUTH in .wskprops under the system HOME directory.)")
- } else {
- errStr = wski18n.T("Authentication key is missing (Please configure testing.auth as the path of the authentication key file in whisk.properties under the OPENWHISK_HOME directory.)")
- }
- return MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, DISPLAY_USAGE)
- } else {
- return nil
- }
- }
+var ValidateWskprops = func(wskprops *Wskprops) error {
+ // There are at least two fields: WHISKAPIURL and AuthKey, mandatory for a valid Wskprops.
+ errStr := ""
+ if len(wskprops.APIHost) == 0 {
+ if wskprops.Source == WHISK_PROPERTY {
+ errStr = wski18n.T("OpenWhisk API host is missing (Please configure WHISK_APIHOST in .wskprops under the system HOME directory.)")
+ } else {
+ errStr = wski18n.T("OpenWhisk API host is missing (Please configure whisk.api.host.proto, whisk.api.host.name and whisk.api.host.port in whisk.properties under the OPENWHISK_HOME directory.)")
+ }
+ return MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, DISPLAY_USAGE)
+ } else {
+ if len(wskprops.AuthKey) == 0 {
+ if wskprops.Source == WHISK_PROPERTY {
+ errStr = wski18n.T("Authentication key is missing (Please configure AUTH in .wskprops under the system HOME directory.)")
+ } else {
+ errStr = wski18n.T("Authentication key is missing (Please configure testing.auth as the path of the authentication key file in whisk.properties under the OPENWHISK_HOME directory.)")
+ }
+ return MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, DISPLAY_USAGE)
+ } else {
+ return nil
+ }
+ }
}
type OSPackage interface {
- Getenv(key string, defaultValue string) string
+ Getenv(key string, defaultValue string) string
}
-type OSPackageImp struct {}
+type OSPackageImp struct{}
func (osPackage OSPackageImp) Getenv(key string, defaultValue string) string {
- value := os.Getenv(key)
- if len(value) == 0 {
- return defaultValue
- }
- return value
+ value := os.Getenv(key)
+ if len(value) == 0 {
+ return defaultValue
+ }
+ return value
}
func GetDefaultConfig() (*Config, error) {
- pi := PropertiesImp{
- OsPackage: OSPackageImp{},
- }
- return GetDefaultConfigFromProperties(pi)
+ pi := PropertiesImp{
+ OsPackage: OSPackageImp{},
+ }
+ return GetDefaultConfigFromProperties(pi)
}
func GetWhiskPropertiesConfig() (*Config, error) {
- pi := PropertiesImp{
- OsPackage: OSPackageImp{},
- }
- return GetConfigFromWhiskProperties(pi)
+ pi := PropertiesImp{
+ OsPackage: OSPackageImp{},
+ }
+ return GetConfigFromWhiskProperties(pi)
}
func GetProperties() Properties {
- return PropertiesImp{
- OsPackage: OSPackageImp{},
- }
+ return PropertiesImp{
+ OsPackage: OSPackageImp{},
+ }
}
func GetWskpropsConfig(path string) (*Config, error) {
- pi := GetProperties()
- return GetConfigFromWskprops(pi, path)
+ pi := GetProperties()
+ return GetConfigFromWskprops(pi, path)
}
func GetDefaultWskprops(source string) *Wskprops {
- if len(source) == 0 {
- source = DEFAULT_SOURCE
- }
-
- dep := Wskprops {
- APIHost: "",
- AuthKey: "",
- Namespace: DEFAULT_NAMESPACE,
- AuthAPIGWKey: "",
- APIGWSpaceSuid: "",
- Apiversion: DEFAULT_VERSION,
- Key: "",
- Cert: "",
- Source: source,
- }
- return &dep
+ if len(source) == 0 {
+ source = DEFAULT_SOURCE
+ }
+
+ dep := Wskprops{
+ APIHost: "",
+ AuthKey: "",
+ Namespace: DEFAULT_NAMESPACE,
+ AuthAPIGWKey: "",
+ APIGWSpaceSuid: "",
+ Apiversion: DEFAULT_VERSION,
+ Key: "",
+ Cert: "",
+ Source: source,
+ }
+ return &dep
}
func GetValue(StoredValues map[string]string, key string, defaultvalue string) string {
- if val, ok := StoredValues[key]; ok {
- return val
- } else {
- return defaultvalue
- }
+ if val, ok := StoredValues[key]; ok {
+ return val
+ } else {
+ return defaultvalue
+ }
}
func ReadProps(path string) (map[string]string, error) {
- props := map[string]string{}
-
- file, err := os.Open(path)
- if err != nil {
- return props, err
- }
- defer file.Close()
-
- lines := []string{}
- scanner := bufio.NewScanner(file)
- for scanner.Scan() {
- lines = append(lines, scanner.Text())
- }
-
- props = map[string]string{}
- for _, line := range lines {
- kv := strings.Split(line, "=")
- if len(kv) != 2 {
- continue
- }
- key := strings.TrimSpace(kv[0])
- value := strings.TrimSpace(kv[1])
- props[key] = value
- }
-
- return props, nil
+ props := map[string]string{}
+
+ file, err := os.Open(path)
+ if err != nil {
+ return props, err
+ }
+ defer file.Close()
+
+ lines := []string{}
+ scanner := bufio.NewScanner(file)
+ for scanner.Scan() {
+ lines = append(lines, scanner.Text())
+ }
+
+ props = map[string]string{}
+ for _, line := range lines {
+ kv := strings.Split(line, "=")
+ if len(kv) != 2 {
+ continue
+ }
+ key := strings.TrimSpace(kv[0])
+ value := strings.TrimSpace(kv[1])
+ props[key] = value
+ }
+
+ return props, nil
}
diff --git a/whisk/wskprops_test.go b/whisk/wskprops_test.go
index ce2b890..e702760 100644
--- a/whisk/wskprops_test.go
+++ b/whisk/wskprops_test.go
@@ -20,78 +20,78 @@
package whisk
import (
- "testing"
- "github.com/stretchr/testify/assert"
- "os"
- "fmt"
- "bufio"
+ "bufio"
+ "fmt"
+ "github.com/stretchr/testify/assert"
+ "os"
+ "testing"
)
const (
- TEST_FILE = "TEST_AUTH_FILE"
- NON_EXISTING_TEST_FILE = "NON_EXISTING_TEST_FILE"
- EXPECTED_OPENWHISK_HOST = "192.168.9.100"
- EXPECTED_OPENWHISK_PORT = "443"
- EXPECTED_OPENWHISK_PRO = "https"
- EXPECTED_TEST_AUTH_KEY = EXPECTED_API_GW_SPACE_SUID + ":123zO3xZCLrMN6v2BKK1dXYFpXlPkccOFqm12CdAsMgRU4VrNZ9lyGVCGuMDGouh"
- EXPECTED_API_HOST= EXPECTED_OPENWHISK_PRO + "://" + EXPECTED_OPENWHISK_HOST + "/api"
- EXPECTED_HOST= EXPECTED_OPENWHISK_HOST + ":" + EXPECTED_OPENWHISK_PORT
- EXPECTED_AUTH_API_KEY = "EXPECTED_AUTH_API_KEY"
- EXPECTED_API_GW_SPACE_SUID = "32kc46b1-71f6-4ed5-8c54-816aa4f8c502"
- APIGW_SPACE_SUID = "APIGW_SPACE_SUID"
- EXPECTED_API_VERSION = "v1"
- EXPECTED_CERT = "EXPECTED_CERT"
- EXPECTED_KEY = "EXPECTED_KEY"
-
- EXPECTED_API_HOST_WHISK = "localhost"
- EXPECTED_TEST_AUTH_KEY_WHISK = "EXPECTED_TEST_AUTH_KEY_WHISK"
- EXPECTED_NAMESPACE_WHISK = "EXPECTED_NAMESPACE_WHISK"
- EXPECTED_AUTH_API_KEY_WHISK = "EXPECTED_AUTH_API_KEY_WHISK"
- EXPECTED_API_GW_SPACE_SUID_WHISK = "EXPECTED_API_GW_SPACE_SUID_WHISK"
- EXPECTED_API_VERSION_WHISK = "EXPECTED_API_VERSION_WHISK"
- EXPECTED_CERT_WHISK = "EXPECTED_CERT_WHISK"
- EXPECTED_KEY_WHISK = "EXPECTED_KEY_WHISK"
-
- EXPECTED_API_HOST_LOCAL_CONF = "hostname"
- EXPECTED_TEST_AUTH_KEY_LOCAL_CONF = "EXPECTED_TEST_AUTH_KEY_LOCAL_CONF"
- EXPECTED_NAMESPACE_LOCAL_CONF = "EXPECTED_NAMESPACE_LOCAL_CONF"
- EXPECTED_AUTH_API_KEY_LOCAL_CONF = "EXPECTED_AUTH_API_KEY_LOCAL_CONF"
- EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF = "EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF"
- EXPECTED_API_VERSION_LOCAL_CONF = "EXPECTED_API_VERSION_LOCAL_CONF"
- EXPECTED_CERT_LOCAL_CONF = "EXPECTED_CERT_LOCAL_CONF"
- EXPECTED_KEY_LOCAL_CONF = "EXPECTED_KEY_LOCAL_CONF"
-
- MISSING_AUTH_MESSAGE = "Authentication key is missing"
- MISSING_URL_MESSAGE = "OpenWhisk API host is missing"
+ TEST_FILE = "TEST_AUTH_FILE"
+ NON_EXISTING_TEST_FILE = "NON_EXISTING_TEST_FILE"
+ EXPECTED_OPENWHISK_HOST = "192.168.9.100"
+ EXPECTED_OPENWHISK_PORT = "443"
+ EXPECTED_OPENWHISK_PRO = "https"
+ EXPECTED_TEST_AUTH_KEY = EXPECTED_API_GW_SPACE_SUID + ":123zO3xZCLrMN6v2BKK1dXYFpXlPkccOFqm12CdAsMgRU4VrNZ9lyGVCGuMDGouh"
+ EXPECTED_API_HOST = EXPECTED_OPENWHISK_PRO + "://" + EXPECTED_OPENWHISK_HOST + "/api"
+ EXPECTED_HOST = EXPECTED_OPENWHISK_HOST + ":" + EXPECTED_OPENWHISK_PORT
+ EXPECTED_AUTH_API_KEY = "EXPECTED_AUTH_API_KEY"
+ EXPECTED_API_GW_SPACE_SUID = "32kc46b1-71f6-4ed5-8c54-816aa4f8c502"
+ APIGW_SPACE_SUID = "APIGW_SPACE_SUID"
+ EXPECTED_API_VERSION = "v1"
+ EXPECTED_CERT = "EXPECTED_CERT"
+ EXPECTED_KEY = "EXPECTED_KEY"
+
+ EXPECTED_API_HOST_WHISK = "localhost"
+ EXPECTED_TEST_AUTH_KEY_WHISK = "EXPECTED_TEST_AUTH_KEY_WHISK"
+ EXPECTED_NAMESPACE_WHISK = "EXPECTED_NAMESPACE_WHISK"
+ EXPECTED_AUTH_API_KEY_WHISK = "EXPECTED_AUTH_API_KEY_WHISK"
+ EXPECTED_API_GW_SPACE_SUID_WHISK = "EXPECTED_API_GW_SPACE_SUID_WHISK"
+ EXPECTED_API_VERSION_WHISK = "EXPECTED_API_VERSION_WHISK"
+ EXPECTED_CERT_WHISK = "EXPECTED_CERT_WHISK"
+ EXPECTED_KEY_WHISK = "EXPECTED_KEY_WHISK"
+
+ EXPECTED_API_HOST_LOCAL_CONF = "hostname"
+ EXPECTED_TEST_AUTH_KEY_LOCAL_CONF = "EXPECTED_TEST_AUTH_KEY_LOCAL_CONF"
+ EXPECTED_NAMESPACE_LOCAL_CONF = "EXPECTED_NAMESPACE_LOCAL_CONF"
+ EXPECTED_AUTH_API_KEY_LOCAL_CONF = "EXPECTED_AUTH_API_KEY_LOCAL_CONF"
+ EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF = "EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF"
+ EXPECTED_API_VERSION_LOCAL_CONF = "EXPECTED_API_VERSION_LOCAL_CONF"
+ EXPECTED_CERT_LOCAL_CONF = "EXPECTED_CERT_LOCAL_CONF"
+ EXPECTED_KEY_LOCAL_CONF = "EXPECTED_KEY_LOCAL_CONF"
+
+ MISSING_AUTH_MESSAGE = "Authentication key is missing"
+ MISSING_URL_MESSAGE = "OpenWhisk API host is missing"
)
type FakeOSPackage struct {
- StoredValues map[string]string
+ StoredValues map[string]string
}
func (osPackage FakeOSPackage) Getenv(key string, defaultValue string) string {
- if val, ok := osPackage.StoredValues[key]; ok {
- return val
- } else {
- return defaultValue
- }
+ if val, ok := osPackage.StoredValues[key]; ok {
+ return val
+ } else {
+ return defaultValue
+ }
}
type FakeViperImp struct {
- StoredValues map[string]string
- ReadInErr error
+ StoredValues map[string]string
+ ReadInErr error
}
func (viperImp FakeViperImp) GetString(key string, defaultvalue string) string {
- if val, ok := viperImp.StoredValues[key]; ok {
- return val
- } else {
- return defaultvalue
- }
+ if val, ok := viperImp.StoredValues[key]; ok {
+ return val
+ } else {
+ return defaultvalue
+ }
}
func (viperImp FakeViperImp) ReadInConfig() error {
- return viperImp.ReadInErr
+ return viperImp.ReadInErr
}
func (viperImp FakeViperImp) SetConfigName(in string) {
@@ -101,731 +101,730 @@ func (viperImp FakeViperImp) AddConfigPath(in string) {
}
func getCurrentDir() string {
- dir, err := os.Getwd()
- if err != nil {
- return os.Getenv("GOPATH") + "/src/github.com/apache/incubator-openwhisk-client-go/whisk"
- }
- return dir
+ dir, err := os.Getwd()
+ if err != nil {
+ return os.Getenv("GOPATH") + "/src/github.com/apache/incubator-openwhisk-client-go/whisk"
+ }
+ return dir
}
type FakePropertiesImp struct {
- StoredValues_LOCAL_CONF map[string]string
- StoredValues_WHISK map[string]string
+ StoredValues_LOCAL_CONF map[string]string
+ StoredValues_WHISK map[string]string
}
func (pi FakePropertiesImp) GetPropsFromWskprops(path string) *Wskprops {
- dep := Wskprops {
- APIHost: GetValue(pi.StoredValues_LOCAL_CONF, APIHOST, ""),
- AuthKey: GetValue(pi.StoredValues_LOCAL_CONF, AUTH, ""),
- Namespace: GetValue(pi.StoredValues_LOCAL_CONF, NAMESPACE, ""),
- AuthAPIGWKey: GetValue(pi.StoredValues_LOCAL_CONF, APIGW_ACCESS_TOKEN, ""),
- APIGWSpaceSuid: GetValue(pi.StoredValues_LOCAL_CONF, APIGW_SPACE_SUID, ""),
- Cert: GetValue(pi.StoredValues_LOCAL_CONF, CERT, ""),
- Key: GetValue(pi.StoredValues_LOCAL_CONF, KEY, ""),
- Apiversion: GetValue(pi.StoredValues_LOCAL_CONF, APIVERSION, ""),
- }
-
- return &dep
+ dep := Wskprops{
+ APIHost: GetValue(pi.StoredValues_LOCAL_CONF, APIHOST, ""),
+ AuthKey: GetValue(pi.StoredValues_LOCAL_CONF, AUTH, ""),
+ Namespace: GetValue(pi.StoredValues_LOCAL_CONF, NAMESPACE, ""),
+ AuthAPIGWKey: GetValue(pi.StoredValues_LOCAL_CONF, APIGW_ACCESS_TOKEN, ""),
+ APIGWSpaceSuid: GetValue(pi.StoredValues_LOCAL_CONF, APIGW_SPACE_SUID, ""),
+ Cert: GetValue(pi.StoredValues_LOCAL_CONF, CERT, ""),
+ Key: GetValue(pi.StoredValues_LOCAL_CONF, KEY, ""),
+ Apiversion: GetValue(pi.StoredValues_LOCAL_CONF, APIVERSION, ""),
+ }
+
+ return &dep
}
func (pi FakePropertiesImp) GetPropsFromWhiskProperties() *Wskprops {
- dep := Wskprops {
- APIHost: pi.StoredValues_WHISK[APIHOST],
- AuthKey: pi.StoredValues_WHISK[AUTH],
- Namespace: pi.StoredValues_WHISK[NAMESPACE],
- AuthAPIGWKey: pi.StoredValues_WHISK[APIGW_ACCESS_TOKEN],
- APIGWSpaceSuid: pi.StoredValues_WHISK[APIGW_SPACE_SUID],
- Cert: pi.StoredValues_WHISK[CERT],
- Key: pi.StoredValues_WHISK[KEY],
- Apiversion: pi.StoredValues_WHISK[APIVERSION],
- }
- return &dep
+ dep := Wskprops{
+ APIHost: pi.StoredValues_WHISK[APIHOST],
+ AuthKey: pi.StoredValues_WHISK[AUTH],
+ Namespace: pi.StoredValues_WHISK[NAMESPACE],
+ AuthAPIGWKey: pi.StoredValues_WHISK[APIGW_ACCESS_TOKEN],
+ APIGWSpaceSuid: pi.StoredValues_WHISK[APIGW_SPACE_SUID],
+ Cert: pi.StoredValues_WHISK[CERT],
+ Key: pi.StoredValues_WHISK[KEY],
+ Apiversion: pi.StoredValues_WHISK[APIVERSION],
+ }
+ return &dep
}
func CreateFile(lines []string, path string) error {
- file, err := os.Create(path)
- if err != nil {
- return err
- }
- defer file.Close()
-
- w := bufio.NewWriter(file)
- for _, line := range lines {
- fmt.Fprintln(w, line)
- }
- return w.Flush()
+ file, err := os.Create(path)
+ if err != nil {
+ return err
+ }
+ defer file.Close()
+
+ w := bufio.NewWriter(file)
+ for _, line := range lines {
+ fmt.Fprintln(w, line)
+ }
+ return w.Flush()
}
func DeleteFile(path string) error {
- return os.Remove(path)
+ return os.Remove(path)
}
func TestGetPropsFromWhiskProperties(t *testing.T) {
- lines := []string{ EXPECTED_TEST_AUTH_KEY }
- CreateFile(lines, TEST_FILE)
-
- fakeOSPackage := FakeOSPackage {
- StoredValues: map[string]string {
- OPENWHISK_HOME: getCurrentDir(),
- },
- }
- pi := PropertiesImp{
- OsPackage: fakeOSPackage,
- }
-
- dep := pi.GetPropsFromWhiskProperties()
- assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
- assert.Equal(t, "", dep.AuthKey)
- assert.Equal(t, "", dep.AuthAPIGWKey)
- assert.Equal(t, "", dep.APIHost)
- assert.Equal(t, "", dep.APIGWSpaceSuid)
- assert.Equal(t, DEFAULT_VERSION, dep.Apiversion)
- assert.Equal(t, "", dep.Key)
- assert.Equal(t, "", dep.Cert)
- assert.Equal(t, WHISK_PROPERTY, dep.Source)
-
- lines = []string{ TEST_AUTH_FILE + "=" + TEST_FILE, OPENWHISK_PRO + "=" + EXPECTED_OPENWHISK_PRO,
- OPENWHISK_PORT + "=" + EXPECTED_OPENWHISK_PORT,
- OPENWHISK_HOST + "=" + EXPECTED_OPENWHISK_HOST,
- }
-
-
- CreateFile(lines, OPENWHISK_PROPERTIES)
- pi = PropertiesImp{
- OsPackage: fakeOSPackage,
- }
- dep = pi.GetPropsFromWhiskProperties()
- assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
- assert.Equal(t, "", dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_OPENWHISK_HOST, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
- assert.Equal(t, DEFAULT_VERSION, dep.Apiversion)
- assert.Equal(t, "", dep.Key)
- assert.Equal(t, "", dep.Cert)
- assert.Equal(t, WHISK_PROPERTY, dep.Source)
-
- DeleteFile(OPENWHISK_PROPERTIES)
-
- DeleteFile(NON_EXISTING_TEST_FILE)
- lines = []string{ TEST_AUTH_FILE + "=" + NON_EXISTING_TEST_FILE, OPENWHISK_PRO + "=" + EXPECTED_OPENWHISK_PRO,
- OPENWHISK_PORT + "=" + EXPECTED_OPENWHISK_PORT,
- OPENWHISK_HOST + "=" + EXPECTED_OPENWHISK_HOST}
- CreateFile(lines, OPENWHISK_PROPERTIES)
- pi = PropertiesImp{
- OsPackage: fakeOSPackage,
- }
- dep = pi.GetPropsFromWhiskProperties()
- assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
- assert.Equal(t, "", dep.AuthKey)
- assert.Equal(t, "", dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_OPENWHISK_HOST, dep.APIHost)
- assert.Equal(t, "", dep.APIGWSpaceSuid)
- assert.Equal(t, DEFAULT_VERSION, dep.Apiversion)
- assert.Equal(t, "", dep.Key)
- assert.Equal(t, "", dep.Cert)
- assert.Equal(t, WHISK_PROPERTY, dep.Source)
- DeleteFile(OPENWHISK_PROPERTIES)
-
- DeleteFile(TEST_FILE)
+ lines := []string{EXPECTED_TEST_AUTH_KEY}
+ CreateFile(lines, TEST_FILE)
+
+ fakeOSPackage := FakeOSPackage{
+ StoredValues: map[string]string{
+ OPENWHISK_HOME: getCurrentDir(),
+ },
+ }
+ pi := PropertiesImp{
+ OsPackage: fakeOSPackage,
+ }
+
+ dep := pi.GetPropsFromWhiskProperties()
+ assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+ assert.Equal(t, "", dep.AuthKey)
+ assert.Equal(t, "", dep.AuthAPIGWKey)
+ assert.Equal(t, "", dep.APIHost)
+ assert.Equal(t, "", dep.APIGWSpaceSuid)
+ assert.Equal(t, DEFAULT_VERSION, dep.Apiversion)
+ assert.Equal(t, "", dep.Key)
+ assert.Equal(t, "", dep.Cert)
+ assert.Equal(t, WHISK_PROPERTY, dep.Source)
+
+ lines = []string{TEST_AUTH_FILE + "=" + TEST_FILE, OPENWHISK_PRO + "=" + EXPECTED_OPENWHISK_PRO,
+ OPENWHISK_PORT + "=" + EXPECTED_OPENWHISK_PORT,
+ OPENWHISK_HOST + "=" + EXPECTED_OPENWHISK_HOST,
+ }
+
+ CreateFile(lines, OPENWHISK_PROPERTIES)
+ pi = PropertiesImp{
+ OsPackage: fakeOSPackage,
+ }
+ dep = pi.GetPropsFromWhiskProperties()
+ assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
+ assert.Equal(t, "", dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_OPENWHISK_HOST, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
+ assert.Equal(t, DEFAULT_VERSION, dep.Apiversion)
+ assert.Equal(t, "", dep.Key)
+ assert.Equal(t, "", dep.Cert)
+ assert.Equal(t, WHISK_PROPERTY, dep.Source)
+
+ DeleteFile(OPENWHISK_PROPERTIES)
+
+ DeleteFile(NON_EXISTING_TEST_FILE)
+ lines = []string{TEST_AUTH_FILE + "=" + NON_EXISTING_TEST_FILE, OPENWHISK_PRO + "=" + EXPECTED_OPENWHISK_PRO,
+ OPENWHISK_PORT + "=" + EXPECTED_OPENWHISK_PORT,
+ OPENWHISK_HOST + "=" + EXPECTED_OPENWHISK_HOST}
+ CreateFile(lines, OPENWHISK_PROPERTIES)
+ pi = PropertiesImp{
+ OsPackage: fakeOSPackage,
+ }
+ dep = pi.GetPropsFromWhiskProperties()
+ assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+ assert.Equal(t, "", dep.AuthKey)
+ assert.Equal(t, "", dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_OPENWHISK_HOST, dep.APIHost)
+ assert.Equal(t, "", dep.APIGWSpaceSuid)
+ assert.Equal(t, DEFAULT_VERSION, dep.Apiversion)
+ assert.Equal(t, "", dep.Key)
+ assert.Equal(t, "", dep.Cert)
+ assert.Equal(t, WHISK_PROPERTY, dep.Source)
+ DeleteFile(OPENWHISK_PROPERTIES)
+
+ DeleteFile(TEST_FILE)
}
func TestGetPropsFromWskprops(t *testing.T) {
- lines := []string{ APIHOST + "=" + EXPECTED_HOST, AUTH + "=" + EXPECTED_TEST_AUTH_KEY,
- NAMESPACE + "=" + DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN + "=" + EXPECTED_AUTH_API_KEY, APIVERSION + "=" + EXPECTED_API_VERSION,
- KEY + "=" + EXPECTED_KEY, CERT + "=" + EXPECTED_CERT}
- CreateFile(lines, DEFAULT_LOCAL_CONFIG)
-
- fakeOSPackage := FakeOSPackage{
- StoredValues: map[string]string {
- HOMEPATH: getCurrentDir(),
- },
- }
- pi := PropertiesImp{
- OsPackage: fakeOSPackage,
- }
-
- dep := pi.GetPropsFromWskprops("")
- assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_HOST, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION, dep.Apiversion)
- assert.Equal(t, EXPECTED_KEY, dep.Key)
- assert.Equal(t, EXPECTED_CERT, dep.Cert)
- assert.Equal(t, WSKPROP, dep.Source)
-
- path := getCurrentDir() + "/" + DEFAULT_LOCAL_CONFIG
- dep = pi.GetPropsFromWskprops(path)
- assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_HOST, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION, dep.Apiversion)
- assert.Equal(t, EXPECTED_KEY, dep.Key)
- assert.Equal(t, EXPECTED_CERT, dep.Cert)
- assert.Equal(t, WSKPROP, dep.Source)
-
- DeleteFile(DEFAULT_LOCAL_CONFIG)
+ lines := []string{APIHOST + "=" + EXPECTED_HOST, AUTH + "=" + EXPECTED_TEST_AUTH_KEY,
+ NAMESPACE + "=" + DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN + "=" + EXPECTED_AUTH_API_KEY, APIVERSION + "=" + EXPECTED_API_VERSION,
+ KEY + "=" + EXPECTED_KEY, CERT + "=" + EXPECTED_CERT}
+ CreateFile(lines, DEFAULT_LOCAL_CONFIG)
+
+ fakeOSPackage := FakeOSPackage{
+ StoredValues: map[string]string{
+ HOMEPATH: getCurrentDir(),
+ },
+ }
+ pi := PropertiesImp{
+ OsPackage: fakeOSPackage,
+ }
+
+ dep := pi.GetPropsFromWskprops("")
+ assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_HOST, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION, dep.Apiversion)
+ assert.Equal(t, EXPECTED_KEY, dep.Key)
+ assert.Equal(t, EXPECTED_CERT, dep.Cert)
+ assert.Equal(t, WSKPROP, dep.Source)
+
+ path := getCurrentDir() + "/" + DEFAULT_LOCAL_CONFIG
+ dep = pi.GetPropsFromWskprops(path)
+ assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_HOST, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION, dep.Apiversion)
+ assert.Equal(t, EXPECTED_KEY, dep.Key)
+ assert.Equal(t, EXPECTED_CERT, dep.Cert)
+ assert.Equal(t, WSKPROP, dep.Source)
+
+ DeleteFile(DEFAULT_LOCAL_CONFIG)
}
func TestGetDefaultConfigFromProperties(t *testing.T) {
- fakeProperties := FakePropertiesImp{
- StoredValues_LOCAL_CONF: map[string]string {
- APIHOST: EXPECTED_OPENWHISK_HOST,
- AUTH: EXPECTED_AUTH_API_KEY,
- NAMESPACE: DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
- APIVERSION: EXPECTED_API_VERSION,
- CERT: EXPECTED_CERT,
- KEY: EXPECTED_KEY,
- },
- }
-
- config, err := GetDefaultConfigFromProperties(fakeProperties)
- assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
- assert.Equal(t, EXPECTED_CERT, config.Cert)
- assert.Equal(t, EXPECTED_KEY, config.Key)
- assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
- assert.Equal(t, EXPECTED_OPENWHISK_HOST, config.Host)
- assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
- assert.Equal(t, EXPECTED_API_VERSION, config.Version)
- assert.False(t, config.Verbose)
- assert.False(t, config.Debug)
- assert.True(t, config.Insecure)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: map[string]string {
- AUTH: EXPECTED_AUTH_API_KEY,
- NAMESPACE: DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
- APIVERSION: EXPECTED_API_VERSION,
- CERT: EXPECTED_CERT,
- KEY: EXPECTED_KEY,
- },
- }
-
- config, err = GetDefaultConfigFromProperties(fakeProperties)
- assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
- assert.Equal(t, EXPECTED_CERT, config.Cert)
- assert.Equal(t, EXPECTED_KEY, config.Key)
- assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
- assert.Equal(t, "", config.Host)
- assert.Nil(t, config.BaseURL)
- assert.Equal(t, EXPECTED_API_VERSION, config.Version)
- assert.False(t, config.Verbose)
- assert.False(t, config.Debug)
- assert.True(t, config.Insecure)
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: map[string]string {
- APIHOST: EXPECTED_OPENWHISK_HOST,
- NAMESPACE: DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
- APIVERSION: EXPECTED_API_VERSION,
- CERT: EXPECTED_CERT,
- KEY: EXPECTED_KEY,
- },
- }
-
- config, err = GetDefaultConfigFromProperties(fakeProperties)
- assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
- assert.Equal(t, EXPECTED_CERT, config.Cert)
- assert.Equal(t, EXPECTED_KEY, config.Key)
- assert.Equal(t, "", config.AuthToken)
- assert.Equal(t, EXPECTED_OPENWHISK_HOST, config.Host)
- assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
- assert.Equal(t, EXPECTED_API_VERSION, config.Version)
- assert.False(t, config.Verbose)
- assert.False(t, config.Debug)
- assert.True(t, config.Insecure)
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
+ fakeProperties := FakePropertiesImp{
+ StoredValues_LOCAL_CONF: map[string]string{
+ APIHOST: EXPECTED_OPENWHISK_HOST,
+ AUTH: EXPECTED_AUTH_API_KEY,
+ NAMESPACE: DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+ APIVERSION: EXPECTED_API_VERSION,
+ CERT: EXPECTED_CERT,
+ KEY: EXPECTED_KEY,
+ },
+ }
+
+ config, err := GetDefaultConfigFromProperties(fakeProperties)
+ assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
+ assert.Equal(t, EXPECTED_CERT, config.Cert)
+ assert.Equal(t, EXPECTED_KEY, config.Key)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
+ assert.Equal(t, EXPECTED_OPENWHISK_HOST, config.Host)
+ assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
+ assert.Equal(t, EXPECTED_API_VERSION, config.Version)
+ assert.False(t, config.Verbose)
+ assert.False(t, config.Debug)
+ assert.True(t, config.Insecure)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: map[string]string{
+ AUTH: EXPECTED_AUTH_API_KEY,
+ NAMESPACE: DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+ APIVERSION: EXPECTED_API_VERSION,
+ CERT: EXPECTED_CERT,
+ KEY: EXPECTED_KEY,
+ },
+ }
+
+ config, err = GetDefaultConfigFromProperties(fakeProperties)
+ assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
+ assert.Equal(t, EXPECTED_CERT, config.Cert)
+ assert.Equal(t, EXPECTED_KEY, config.Key)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
+ assert.Equal(t, "", config.Host)
+ assert.Nil(t, config.BaseURL)
+ assert.Equal(t, EXPECTED_API_VERSION, config.Version)
+ assert.False(t, config.Verbose)
+ assert.False(t, config.Debug)
+ assert.True(t, config.Insecure)
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: map[string]string{
+ APIHOST: EXPECTED_OPENWHISK_HOST,
+ NAMESPACE: DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+ APIVERSION: EXPECTED_API_VERSION,
+ CERT: EXPECTED_CERT,
+ KEY: EXPECTED_KEY,
+ },
+ }
+
+ config, err = GetDefaultConfigFromProperties(fakeProperties)
+ assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
+ assert.Equal(t, EXPECTED_CERT, config.Cert)
+ assert.Equal(t, EXPECTED_KEY, config.Key)
+ assert.Equal(t, "", config.AuthToken)
+ assert.Equal(t, EXPECTED_OPENWHISK_HOST, config.Host)
+ assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
+ assert.Equal(t, EXPECTED_API_VERSION, config.Version)
+ assert.False(t, config.Verbose)
+ assert.False(t, config.Debug)
+ assert.True(t, config.Insecure)
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
}
func TestGetConfigFromWskprops(t *testing.T) {
- fakeProperties := FakePropertiesImp{
- StoredValues_LOCAL_CONF: map[string]string {
- APIHOST: EXPECTED_OPENWHISK_HOST,
- AUTH: EXPECTED_AUTH_API_KEY,
- NAMESPACE: DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
- APIVERSION: EXPECTED_API_VERSION,
- CERT: EXPECTED_CERT,
- KEY: EXPECTED_KEY,
- },
- }
-
- config, err := GetConfigFromWskprops(fakeProperties, "")
- assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
- assert.Equal(t, EXPECTED_CERT, config.Cert)
- assert.Equal(t, EXPECTED_KEY, config.Key)
- assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
- assert.Equal(t, EXPECTED_OPENWHISK_HOST, config.Host)
- assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
- assert.Equal(t, EXPECTED_API_VERSION, config.Version)
- assert.False(t, config.Verbose)
- assert.False(t, config.Debug)
- assert.True(t, config.Insecure)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: map[string]string {
- AUTH: EXPECTED_AUTH_API_KEY,
- NAMESPACE: DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
- APIVERSION: EXPECTED_API_VERSION,
- CERT: EXPECTED_CERT,
- KEY: EXPECTED_KEY,
- },
- }
-
- config, err = GetConfigFromWskprops(fakeProperties, "")
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: map[string]string {
- APIHOST: EXPECTED_OPENWHISK_HOST,
- NAMESPACE: DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
- APIVERSION: EXPECTED_API_VERSION,
- CERT: EXPECTED_CERT,
- KEY: EXPECTED_KEY,
- },
- }
-
- config, err = GetConfigFromWskprops(fakeProperties, "")
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
+ fakeProperties := FakePropertiesImp{
+ StoredValues_LOCAL_CONF: map[string]string{
+ APIHOST: EXPECTED_OPENWHISK_HOST,
+ AUTH: EXPECTED_AUTH_API_KEY,
+ NAMESPACE: DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+ APIVERSION: EXPECTED_API_VERSION,
+ CERT: EXPECTED_CERT,
+ KEY: EXPECTED_KEY,
+ },
+ }
+
+ config, err := GetConfigFromWskprops(fakeProperties, "")
+ assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
+ assert.Equal(t, EXPECTED_CERT, config.Cert)
+ assert.Equal(t, EXPECTED_KEY, config.Key)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
+ assert.Equal(t, EXPECTED_OPENWHISK_HOST, config.Host)
+ assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
+ assert.Equal(t, EXPECTED_API_VERSION, config.Version)
+ assert.False(t, config.Verbose)
+ assert.False(t, config.Debug)
+ assert.True(t, config.Insecure)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: map[string]string{
+ AUTH: EXPECTED_AUTH_API_KEY,
+ NAMESPACE: DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+ APIVERSION: EXPECTED_API_VERSION,
+ CERT: EXPECTED_CERT,
+ KEY: EXPECTED_KEY,
+ },
+ }
+
+ config, err = GetConfigFromWskprops(fakeProperties, "")
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: map[string]string{
+ APIHOST: EXPECTED_OPENWHISK_HOST,
+ NAMESPACE: DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+ APIVERSION: EXPECTED_API_VERSION,
+ CERT: EXPECTED_CERT,
+ KEY: EXPECTED_KEY,
+ },
+ }
+
+ config, err = GetConfigFromWskprops(fakeProperties, "")
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
}
func TestGetConfigFromWhiskProperties(t *testing.T) {
- fakeProperties := FakePropertiesImp{
- StoredValues_WHISK: map[string]string {
- APIHOST: EXPECTED_OPENWHISK_HOST,
- AUTH: EXPECTED_AUTH_API_KEY,
- NAMESPACE: DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
- APIVERSION: EXPECTED_API_VERSION,
- CERT: EXPECTED_CERT,
- KEY: EXPECTED_KEY,
- },
- }
-
- config, err := GetConfigFromWhiskProperties(fakeProperties)
- assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
- assert.Equal(t, EXPECTED_CERT, config.Cert)
- assert.Equal(t, EXPECTED_KEY, config.Key)
- assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
- assert.Equal(t, EXPECTED_OPENWHISK_HOST, config.Host)
- assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
- assert.Equal(t, EXPECTED_API_VERSION, config.Version)
- assert.False(t, config.Verbose)
- assert.False(t, config.Debug)
- assert.True(t, config.Insecure)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_WHISK: map[string]string {
- AUTH: EXPECTED_AUTH_API_KEY,
- NAMESPACE: DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
- APIVERSION: EXPECTED_API_VERSION,
- CERT: EXPECTED_CERT,
- KEY: EXPECTED_KEY,
- },
- }
-
- config, err = GetConfigFromWhiskProperties(fakeProperties)
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_WHISK: map[string]string {
- APIHOST: EXPECTED_OPENWHISK_HOST,
- NAMESPACE: DEFAULT_NAMESPACE,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
- APIVERSION: EXPECTED_API_VERSION,
- CERT: EXPECTED_CERT,
- KEY: EXPECTED_KEY,
- },
- }
-
- config, err = GetConfigFromWhiskProperties(fakeProperties)
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
+ fakeProperties := FakePropertiesImp{
+ StoredValues_WHISK: map[string]string{
+ APIHOST: EXPECTED_OPENWHISK_HOST,
+ AUTH: EXPECTED_AUTH_API_KEY,
+ NAMESPACE: DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+ APIVERSION: EXPECTED_API_VERSION,
+ CERT: EXPECTED_CERT,
+ KEY: EXPECTED_KEY,
+ },
+ }
+
+ config, err := GetConfigFromWhiskProperties(fakeProperties)
+ assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
+ assert.Equal(t, EXPECTED_CERT, config.Cert)
+ assert.Equal(t, EXPECTED_KEY, config.Key)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
+ assert.Equal(t, EXPECTED_OPENWHISK_HOST, config.Host)
+ assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
+ assert.Equal(t, EXPECTED_API_VERSION, config.Version)
+ assert.False(t, config.Verbose)
+ assert.False(t, config.Debug)
+ assert.True(t, config.Insecure)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_WHISK: map[string]string{
+ AUTH: EXPECTED_AUTH_API_KEY,
+ NAMESPACE: DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+ APIVERSION: EXPECTED_API_VERSION,
+ CERT: EXPECTED_CERT,
+ KEY: EXPECTED_KEY,
+ },
+ }
+
+ config, err = GetConfigFromWhiskProperties(fakeProperties)
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_WHISK: map[string]string{
+ APIHOST: EXPECTED_OPENWHISK_HOST,
+ NAMESPACE: DEFAULT_NAMESPACE,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+ APIVERSION: EXPECTED_API_VERSION,
+ CERT: EXPECTED_CERT,
+ KEY: EXPECTED_KEY,
+ },
+ }
+
+ config, err = GetConfigFromWhiskProperties(fakeProperties)
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
}
func TestValidateWskprops(t *testing.T) {
- dep := Wskprops {
- AuthKey: "",
- Namespace: DEFAULT_NAMESPACE,
- AuthAPIGWKey: "",
- APIGWSpaceSuid: "",
- Apiversion: DEFAULT_VERSION,
- Key: "",
- Cert: "",
- }
- err := ValidateWskprops(&dep)
- assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
-
- dep = Wskprops {
- APIHost: EXPECTED_OPENWHISK_HOST,
- AuthKey: "",
- Namespace: DEFAULT_NAMESPACE,
- AuthAPIGWKey: "",
- APIGWSpaceSuid: "",
- Apiversion: DEFAULT_VERSION,
- Key: "",
- Cert: "",
- }
- err = ValidateWskprops(&dep)
- assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
-
- dep = Wskprops {
- APIHost: EXPECTED_OPENWHISK_HOST,
- AuthKey: "auth_key",
- Namespace: DEFAULT_NAMESPACE,
- AuthAPIGWKey: "",
- APIGWSpaceSuid: "",
- Apiversion: DEFAULT_VERSION,
- Key: "",
- Cert: "",
- }
- err = ValidateWskprops(&dep)
- assert.Equal(t, nil, err)
+ dep := Wskprops{
+ AuthKey: "",
+ Namespace: DEFAULT_NAMESPACE,
+ AuthAPIGWKey: "",
+ APIGWSpaceSuid: "",
+ Apiversion: DEFAULT_VERSION,
+ Key: "",
+ Cert: "",
+ }
+ err := ValidateWskprops(&dep)
+ assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
+
+ dep = Wskprops{
+ APIHost: EXPECTED_OPENWHISK_HOST,
+ AuthKey: "",
+ Namespace: DEFAULT_NAMESPACE,
+ AuthAPIGWKey: "",
+ APIGWSpaceSuid: "",
+ Apiversion: DEFAULT_VERSION,
+ Key: "",
+ Cert: "",
+ }
+ err = ValidateWskprops(&dep)
+ assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
+
+ dep = Wskprops{
+ APIHost: EXPECTED_OPENWHISK_HOST,
+ AuthKey: "auth_key",
+ Namespace: DEFAULT_NAMESPACE,
+ AuthAPIGWKey: "",
+ APIGWSpaceSuid: "",
+ Apiversion: DEFAULT_VERSION,
+ Key: "",
+ Cert: "",
+ }
+ err = ValidateWskprops(&dep)
+ assert.Equal(t, nil, err)
}
func TestGetDefaultWskProp(t *testing.T) {
- valid_whisk_values := map[string]string {
- APIHOST: EXPECTED_API_HOST_WHISK,
- AUTH: EXPECTED_TEST_AUTH_KEY_WHISK,
- NAMESPACE: EXPECTED_NAMESPACE_WHISK,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_WHISK,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_WHISK,
- APIVERSION: EXPECTED_API_VERSION_WHISK,
- CERT: EXPECTED_CERT_WHISK,
- KEY: EXPECTED_KEY_WHISK,
- }
- valid_local_conf_values := map[string]string {
- APIHOST: EXPECTED_API_HOST_LOCAL_CONF,
- AUTH: EXPECTED_TEST_AUTH_KEY_LOCAL_CONF,
- NAMESPACE: EXPECTED_NAMESPACE_LOCAL_CONF,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_LOCAL_CONF,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF,
- APIVERSION: EXPECTED_API_VERSION_LOCAL_CONF,
- CERT: EXPECTED_CERT_LOCAL_CONF,
- KEY: EXPECTED_KEY_LOCAL_CONF,
- }
-
- missing_auth_local_conf_values := map[string]string{}
- for k,v := range valid_local_conf_values {
- if k != AUTH {
- missing_auth_local_conf_values[k] = v
- }
- }
-
- missing_url_local_conf_values := map[string]string{}
- for k,v := range valid_local_conf_values {
- if k != APIHOST {
- missing_url_local_conf_values[k] = v
- }
- }
-
- missing_auth_whisk_values := map[string]string{}
- for k,v := range valid_whisk_values {
- if k != AUTH {
- missing_auth_whisk_values[k] = v
- }
- }
-
- missing_url_whisk_values := map[string]string{}
- for k,v := range valid_whisk_values {
- if k != APIHOST {
- missing_url_whisk_values[k] = v
- }
- }
-
- fakeProperties := FakePropertiesImp{
- StoredValues_WHISK: valid_whisk_values,
- }
- dep, err := GetDefaultWskProp(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: valid_local_conf_values,
- }
- dep, err = GetDefaultWskProp(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: valid_local_conf_values,
- StoredValues_WHISK: valid_whisk_values,
- }
- dep, err = GetDefaultWskProp(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: missing_url_local_conf_values,
- StoredValues_WHISK: valid_whisk_values,
- }
- dep, err = GetDefaultWskProp(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
- StoredValues_WHISK: valid_whisk_values,
- }
- dep, err = GetDefaultWskProp(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
- StoredValues_WHISK: missing_auth_whisk_values,
- }
- dep, err = GetDefaultWskProp(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
- assert.Equal(t, "", dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
- assert.NotEqual(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
- StoredValues_WHISK: missing_url_whisk_values,
- }
- dep, err = GetDefaultWskProp(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
- assert.Equal(t, "", dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
- assert.NotEqual(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: missing_url_local_conf_values,
- StoredValues_WHISK: missing_auth_whisk_values,
- }
- dep, err = GetDefaultWskProp(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
- assert.Equal(t, "", dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
- assert.NotEqual(t, nil, err)
+ valid_whisk_values := map[string]string{
+ APIHOST: EXPECTED_API_HOST_WHISK,
+ AUTH: EXPECTED_TEST_AUTH_KEY_WHISK,
+ NAMESPACE: EXPECTED_NAMESPACE_WHISK,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_WHISK,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_WHISK,
+ APIVERSION: EXPECTED_API_VERSION_WHISK,
+ CERT: EXPECTED_CERT_WHISK,
+ KEY: EXPECTED_KEY_WHISK,
+ }
+ valid_local_conf_values := map[string]string{
+ APIHOST: EXPECTED_API_HOST_LOCAL_CONF,
+ AUTH: EXPECTED_TEST_AUTH_KEY_LOCAL_CONF,
+ NAMESPACE: EXPECTED_NAMESPACE_LOCAL_CONF,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_LOCAL_CONF,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF,
+ APIVERSION: EXPECTED_API_VERSION_LOCAL_CONF,
+ CERT: EXPECTED_CERT_LOCAL_CONF,
+ KEY: EXPECTED_KEY_LOCAL_CONF,
+ }
+
+ missing_auth_local_conf_values := map[string]string{}
+ for k, v := range valid_local_conf_values {
+ if k != AUTH {
+ missing_auth_local_conf_values[k] = v
+ }
+ }
+
+ missing_url_local_conf_values := map[string]string{}
+ for k, v := range valid_local_conf_values {
+ if k != APIHOST {
+ missing_url_local_conf_values[k] = v
+ }
+ }
+
+ missing_auth_whisk_values := map[string]string{}
+ for k, v := range valid_whisk_values {
+ if k != AUTH {
+ missing_auth_whisk_values[k] = v
+ }
+ }
+
+ missing_url_whisk_values := map[string]string{}
+ for k, v := range valid_whisk_values {
+ if k != APIHOST {
+ missing_url_whisk_values[k] = v
+ }
+ }
+
+ fakeProperties := FakePropertiesImp{
+ StoredValues_WHISK: valid_whisk_values,
+ }
+ dep, err := GetDefaultWskProp(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: valid_local_conf_values,
+ }
+ dep, err = GetDefaultWskProp(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: valid_local_conf_values,
+ StoredValues_WHISK: valid_whisk_values,
+ }
+ dep, err = GetDefaultWskProp(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: missing_url_local_conf_values,
+ StoredValues_WHISK: valid_whisk_values,
+ }
+ dep, err = GetDefaultWskProp(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
+ StoredValues_WHISK: valid_whisk_values,
+ }
+ dep, err = GetDefaultWskProp(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
+ StoredValues_WHISK: missing_auth_whisk_values,
+ }
+ dep, err = GetDefaultWskProp(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+ assert.Equal(t, "", dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+ assert.NotEqual(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
+ StoredValues_WHISK: missing_url_whisk_values,
+ }
+ dep, err = GetDefaultWskProp(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+ assert.Equal(t, "", dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+ assert.NotEqual(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: missing_url_local_conf_values,
+ StoredValues_WHISK: missing_auth_whisk_values,
+ }
+ dep, err = GetDefaultWskProp(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+ assert.Equal(t, "", dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+ assert.NotEqual(t, nil, err)
}
func TestGetWskPropFromWskprops(t *testing.T) {
- valid_local_conf_values := map[string]string{
- APIHOST: EXPECTED_API_HOST_LOCAL_CONF,
- AUTH: EXPECTED_TEST_AUTH_KEY_LOCAL_CONF,
- NAMESPACE: EXPECTED_NAMESPACE_LOCAL_CONF,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_LOCAL_CONF,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF,
- APIVERSION: EXPECTED_API_VERSION_LOCAL_CONF,
- CERT: EXPECTED_CERT_LOCAL_CONF,
- KEY: EXPECTED_KEY_LOCAL_CONF,
- }
-
- missing_auth_local_conf_values := map[string]string{}
- for k, v := range valid_local_conf_values {
- if k != AUTH {
- missing_auth_local_conf_values[k] = v
- }
- }
-
- missing_url_local_conf_values := map[string]string{}
- for k, v := range valid_local_conf_values {
- if k != APIHOST {
- missing_url_local_conf_values[k] = v
- }
- }
-
- fakeProperties := FakePropertiesImp{
- StoredValues_LOCAL_CONF: valid_local_conf_values,
- }
-
- dep, err := GetWskPropFromWskprops(fakeProperties, "")
- assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: missing_url_local_conf_values,
- }
- dep, err = GetWskPropFromWskprops(fakeProperties, "")
- assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
- assert.Equal(t, "", dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
- }
- dep, err = GetWskPropFromWskprops(fakeProperties, "")
- assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
- assert.Equal(t, "", dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
+ valid_local_conf_values := map[string]string{
+ APIHOST: EXPECTED_API_HOST_LOCAL_CONF,
+ AUTH: EXPECTED_TEST_AUTH_KEY_LOCAL_CONF,
+ NAMESPACE: EXPECTED_NAMESPACE_LOCAL_CONF,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_LOCAL_CONF,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF,
+ APIVERSION: EXPECTED_API_VERSION_LOCAL_CONF,
+ CERT: EXPECTED_CERT_LOCAL_CONF,
+ KEY: EXPECTED_KEY_LOCAL_CONF,
+ }
+
+ missing_auth_local_conf_values := map[string]string{}
+ for k, v := range valid_local_conf_values {
+ if k != AUTH {
+ missing_auth_local_conf_values[k] = v
+ }
+ }
+
+ missing_url_local_conf_values := map[string]string{}
+ for k, v := range valid_local_conf_values {
+ if k != APIHOST {
+ missing_url_local_conf_values[k] = v
+ }
+ }
+
+ fakeProperties := FakePropertiesImp{
+ StoredValues_LOCAL_CONF: valid_local_conf_values,
+ }
+
+ dep, err := GetWskPropFromWskprops(fakeProperties, "")
+ assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: missing_url_local_conf_values,
+ }
+ dep, err = GetWskPropFromWskprops(fakeProperties, "")
+ assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+ assert.Equal(t, "", dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
+ }
+ dep, err = GetWskPropFromWskprops(fakeProperties, "")
+ assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+ assert.Equal(t, "", dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
}
func TestGetWskPropFromWhiskProperty(t *testing.T) {
- valid_whisk_values := map[string]string {
- APIHOST: EXPECTED_API_HOST_WHISK,
- AUTH: EXPECTED_TEST_AUTH_KEY_WHISK,
- NAMESPACE: EXPECTED_NAMESPACE_WHISK,
- APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_WHISK,
- APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_WHISK,
- APIVERSION: EXPECTED_API_VERSION_WHISK,
- CERT: EXPECTED_CERT_WHISK,
- KEY: EXPECTED_KEY_WHISK,
- }
-
- missing_auth_whisk_values := map[string]string{}
- for k,v := range valid_whisk_values {
- if k != AUTH {
- missing_auth_whisk_values[k] = v
- }
- }
-
- missing_url_whisk_values := map[string]string{}
- for k,v := range valid_whisk_values {
- if k != APIHOST {
- missing_url_whisk_values[k] = v
- }
- }
-
- fakeProperties := FakePropertiesImp{
- StoredValues_WHISK: valid_whisk_values,
- }
-
- dep, err := GetWskPropFromWhiskProperty(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
- assert.Equal(t, nil, err)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_WHISK: missing_auth_whisk_values,
- }
-
- dep, err = GetWskPropFromWhiskProperty(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
- assert.Equal(t, "", dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
- assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
-
- fakeProperties = FakePropertiesImp{
- StoredValues_WHISK: missing_url_whisk_values,
- }
-
- dep, err = GetWskPropFromWhiskProperty(fakeProperties)
- assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
- assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
- assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
- assert.Equal(t, "", dep.APIHost)
- assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
- assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
- assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
- assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
- assert.NotEqual(t, nil, err)
- assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
+ valid_whisk_values := map[string]string{
+ APIHOST: EXPECTED_API_HOST_WHISK,
+ AUTH: EXPECTED_TEST_AUTH_KEY_WHISK,
+ NAMESPACE: EXPECTED_NAMESPACE_WHISK,
+ APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_WHISK,
+ APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_WHISK,
+ APIVERSION: EXPECTED_API_VERSION_WHISK,
+ CERT: EXPECTED_CERT_WHISK,
+ KEY: EXPECTED_KEY_WHISK,
+ }
+
+ missing_auth_whisk_values := map[string]string{}
+ for k, v := range valid_whisk_values {
+ if k != AUTH {
+ missing_auth_whisk_values[k] = v
+ }
+ }
+
+ missing_url_whisk_values := map[string]string{}
+ for k, v := range valid_whisk_values {
+ if k != APIHOST {
+ missing_url_whisk_values[k] = v
+ }
+ }
+
+ fakeProperties := FakePropertiesImp{
+ StoredValues_WHISK: valid_whisk_values,
+ }
+
+ dep, err := GetWskPropFromWhiskProperty(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+ assert.Equal(t, nil, err)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_WHISK: missing_auth_whisk_values,
+ }
+
+ dep, err = GetWskPropFromWhiskProperty(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+ assert.Equal(t, "", dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+ assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
+
+ fakeProperties = FakePropertiesImp{
+ StoredValues_WHISK: missing_url_whisk_values,
+ }
+
+ dep, err = GetWskPropFromWhiskProperty(fakeProperties)
+ assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+ assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+ assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+ assert.Equal(t, "", dep.APIHost)
+ assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+ assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+ assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+ assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+ assert.NotEqual(t, nil, err)
+ assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)
}
diff --git a/wski18n/detection.go b/wski18n/detection.go
index b442cc4..c3866dd 100644
--- a/wski18n/detection.go
+++ b/wski18n/detection.go
@@ -20,24 +20,24 @@ package wski18n
import "github.com/cloudfoundry/jibber_jabber"
type Detector interface {
- DetectLocale() string
- DetectLanguage() string
+ DetectLocale() string
+ DetectLanguage() string
}
type JibberJabberDetector struct{}
func (d *JibberJabberDetector) DetectLocale() string {
- userLocale, err := jibber_jabber.DetectIETF()
- if err != nil {
- userLocale = ""
- }
- return userLocale
+ userLocale, err := jibber_jabber.DetectIETF()
+ if err != nil {
+ userLocale = ""
+ }
+ return userLocale
}
func (d *JibberJabberDetector) DetectLanguage() string {
- lang, err := jibber_jabber.DetectLanguage()
- if err != nil {
- lang = ""
- }
- return lang
+ lang, err := jibber_jabber.DetectLanguage()
+ if err != nil {
+ lang = ""
+ }
+ return lang
}
diff --git a/wski18n/i18n.go b/wski18n/i18n.go
index 9991ac8..02a25d3 100644
--- a/wski18n/i18n.go
+++ b/wski18n/i18n.go
@@ -18,131 +18,131 @@
package wski18n
import (
- "path/filepath"
- "strings"
+ "path/filepath"
+ "strings"
- goi18n "github.com/nicksnyder/go-i18n/i18n"
+ goi18n "github.com/nicksnyder/go-i18n/i18n"
)
const (
- DEFAULT_LOCALE = "en_US"
+ DEFAULT_LOCALE = "en_US"
)
var SUPPORTED_LOCALES = []string{
- "de_DE",
- "en_US",
- "es_ES",
- "fr_FR",
- "it_IT",
- "ja_JA",
- "ko_KR",
- "pt_BR",
- "zh_Hans",
- "zh_Hant",
+ "de_DE",
+ "en_US",
+ "es_ES",
+ "fr_FR",
+ "it_IT",
+ "ja_JA",
+ "ko_KR",
+ "pt_BR",
+ "zh_Hans",
+ "zh_Hant",
}
var resourcePath = filepath.Join("wski18n", "resources")
func GetResourcePath() string {
- return resourcePath
+ return resourcePath
}
func SetResourcePath(path string) {
- resourcePath = path
+ resourcePath = path
}
var T goi18n.TranslateFunc
var curLocale string
func init() {
- curLocale = Init(new(JibberJabberDetector))
+ curLocale = Init(new(JibberJabberDetector))
}
func CurLocale() string {
- return curLocale
+ return curLocale
}
func Locale(detector Detector) string {
- // Use default locale until strings are translated
- /*sysLocale := normalize(detector.DetectLocale())
- if isSupported(sysLocale) {
- return sysLocale
- }
+ // Use default locale until strings are translated
+ /*sysLocale := normalize(detector.DetectLocale())
+ if isSupported(sysLocale) {
+ return sysLocale
+ }
- locale := defaultLocaleForLang(detector.DetectLanguage())
- if locale != "" {
- return locale
- }*/
+ locale := defaultLocaleForLang(detector.DetectLanguage())
+ if locale != "" {
+ return locale
+ }*/
- return DEFAULT_LOCALE
+ return DEFAULT_LOCALE
}
func Init(detector Detector) string {
- l := Locale(detector)
- InitWithLocale(l)
- return l
+ l := Locale(detector)
+ InitWithLocale(l)
+ return l
}
func InitWithLocale(locale string) {
- err := loadFromAsset(locale)
- if err != nil {
- panic(err)
- }
- T = goi18n.MustTfunc(locale)
+ err := loadFromAsset(locale)
+ if err != nil {
+ panic(err)
+ }
+ T = goi18n.MustTfunc(locale)
}
func loadFromAsset(locale string) (err error) {
- assetName := locale + ".all.json"
- assetKey := filepath.Join(resourcePath, assetName)
- bytes, err := Asset(assetKey)
- if err != nil {
- return
- }
- err = goi18n.ParseTranslationFileBytes(assetName, bytes)
- return
+ assetName := locale + ".all.json"
+ assetKey := filepath.Join(resourcePath, assetName)
+ bytes, err := Asset(assetKey)
+ if err != nil {
+ return
+ }
+ err = goi18n.ParseTranslationFileBytes(assetName, bytes)
+ return
}
func normalize(locale string) string {
- locale = strings.ToLower(strings.Replace(locale, "-", "_", 1))
- for _, l := range SUPPORTED_LOCALES {
- if strings.EqualFold(locale, l) {
- return l
- }
- }
- switch locale {
- case "zh_cn", "zh_sg":
- return "zh_Hans"
- case "zh_hk", "zh_tw":
- return "zh_Hant"
- }
- return locale
+ locale = strings.ToLower(strings.Replace(locale, "-", "_", 1))
+ for _, l := range SUPPORTED_LOCALES {
+ if strings.EqualFold(locale, l) {
+ return l
+ }
+ }
+ switch locale {
+ case "zh_cn", "zh_sg":
+ return "zh_Hans"
+ case "zh_hk", "zh_tw":
+ return "zh_Hant"
+ }
+ return locale
}
func isSupported(locale string) bool {
- for _, l := range SUPPORTED_LOCALES {
- if strings.EqualFold(locale, l) {
- return true
- }
- }
- return false
+ for _, l := range SUPPORTED_LOCALES {
+ if strings.EqualFold(locale, l) {
+ return true
+ }
+ }
+ return false
}
func defaultLocaleForLang(lang string) string {
- if lang != "" {
- lang = strings.ToLower(lang)
- for _, l := range SUPPORTED_LOCALES {
- if lang == LangOfLocale(l) {
- return l
- }
- }
- }
- return ""
+ if lang != "" {
+ lang = strings.ToLower(lang)
+ for _, l := range SUPPORTED_LOCALES {
+ if lang == LangOfLocale(l) {
+ return l
+ }
+ }
+ }
+ return ""
}
func LangOfLocale(locale string) string {
- if len(locale) < 2 {
- return ""
- }
- return locale[0:2]
+ if len(locale) < 2 {
+ return ""
+ }
+ return locale[0:2]
}
diff --git a/wski18n/i18n_resources.go b/wski18n/i18n_resources.go
index 7fa268c..aca3ea6 100644
--- a/wski18n/i18n_resources.go
+++ b/wski18n/i18n_resources.go
@@ -32,330 +32,330 @@
package wski18n
import (
- "bytes"
- "compress/gzip"
- "fmt"
- "io"
- "io/ioutil"
- "os"
- "path/filepath"
- "strings"
- "time"
+ "bytes"
+ "compress/gzip"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "strings"
+ "time"
)
func bindataRead(data []byte, name string) ([]byte, error) {
- gz, err := gzip.NewReader(bytes.NewBuffer(data))
- if err != nil {
- return nil, fmt.Errorf("Read %q: %v", name, err)
- }
+ gz, err := gzip.NewReader(bytes.NewBuffer(data))
+ if err != nil {
+ return nil, fmt.Errorf("Read %q: %v", name, err)
+ }
- var buf bytes.Buffer
- _, err = io.Copy(&buf, gz)
- clErr := gz.Close()
+ var buf bytes.Buffer
+ _, err = io.Copy(&buf, gz)
+ clErr := gz.Close()
- if err != nil {
- return nil, fmt.Errorf("Read %q: %v", name, err)
- }
- if clErr != nil {
- return nil, err
- }
+ if err != nil {
+ return nil, fmt.Errorf("Read %q: %v", name, err)
+ }
+ if clErr != nil {
+ return nil, err
+ }
- return buf.Bytes(), nil
+ return buf.Bytes(), nil
}
type asset struct {
- bytes []byte
- info os.FileInfo
+ bytes []byte
+ info os.FileInfo
}
type bindataFileInfo struct {
- name string
- size int64
- mode os.FileMode
- modTime time.Time
+ name string
+ size int64
+ mode os.FileMode
+ modTime time.Time
}
func (fi bindataFileInfo) Name() string {
- return fi.name
+ return fi.name
}
func (fi bindataFileInfo) Size() int64 {
- return fi.size
+ return fi.size
}
func (fi bindataFileInfo) Mode() os.FileMode {
- return fi.mode
+ return fi.mode
}
func (fi bindataFileInfo) ModTime() time.Time {
- return fi.modTime
+ return fi.modTime
}
func (fi bindataFileInfo) IsDir() bool {
- return false
+ return false
}
func (fi bindataFileInfo) Sys() interface{} {
- return nil
+ return nil
}
var _wski18nResourcesDe_deAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")
func wski18nResourcesDe_deAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesDe_deAllJson,
- "wski18n/resources/de_DE.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesDe_deAllJson,
+ "wski18n/resources/de_DE.all.json",
+ )
}
func wski18nResourcesDe_deAllJson() (*asset, error) {
- bytes, err := wski18nResourcesDe_deAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesDe_deAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/de_DE.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/de_DE.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
var _wski18nResourcesEn_usAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x58\x5f\x6f\xdb\x36\x10\x7f\xf7\xa7\x38\xf8\xc5\x19\xe0\x0a\x7b\xd9\xc3\xba\xa7\xa0\x33\xe6\xa0\x5d\x63\xac\xce\x3a\x60\x19\x06\x46\x3c\x5b\x87\xc8\xa4\x7a\xa4\x9c\xb9\x86\xbe\xfb\x40\xca\x72\xd2\xc4\xb4\xfe\x58\x49\xf3\x64\x81\xe6\xfd\xee\xc7\xbb\xe3\xfd\xe1\xdf\x03\x80\xed\x00\x00\x60\x48\x72\xf8\x16\x86\x57\x4a\xdc\xa4\x08\x56\x83\x90\x12\x58\xe7\x16\x41\x67\x96\xb4\x32\x30\xda\x6e\xa3\xdd\x77\x51 [...]
func wski18nResourcesEn_usAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesEn_usAllJson,
- "wski18n/resources/en_US.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesEn_usAllJson,
+ "wski18n/resources/en_US.all.json",
+ )
}
func wski18nResourcesEn_usAllJson() (*asset, error) {
- bytes, err := wski18nResourcesEn_usAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesEn_usAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/en_US.all.json", size: 7105, mode: os.FileMode(420), modTime: time.Unix(1510603813, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/en_US.all.json", size: 7105, mode: os.FileMode(420), modTime: time.Unix(1510603813, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
var _wski18nResourcesEs_esAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")
func wski18nResourcesEs_esAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesEs_esAllJson,
- "wski18n/resources/es_ES.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesEs_esAllJson,
+ "wski18n/resources/es_ES.all.json",
+ )
}
func wski18nResourcesEs_esAllJson() (*asset, error) {
- bytes, err := wski18nResourcesEs_esAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesEs_esAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/es_ES.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/es_ES.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
var _wski18nResourcesFr_frAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")
func wski18nResourcesFr_frAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesFr_frAllJson,
- "wski18n/resources/fr_FR.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesFr_frAllJson,
+ "wski18n/resources/fr_FR.all.json",
+ )
}
func wski18nResourcesFr_frAllJson() (*asset, error) {
- bytes, err := wski18nResourcesFr_frAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesFr_frAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/fr_FR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/fr_FR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
var _wski18nResourcesIt_itAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")
func wski18nResourcesIt_itAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesIt_itAllJson,
- "wski18n/resources/it_IT.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesIt_itAllJson,
+ "wski18n/resources/it_IT.all.json",
+ )
}
func wski18nResourcesIt_itAllJson() (*asset, error) {
- bytes, err := wski18nResourcesIt_itAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesIt_itAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/it_IT.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/it_IT.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
var _wski18nResourcesJa_jaAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")
func wski18nResourcesJa_jaAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesJa_jaAllJson,
- "wski18n/resources/ja_JA.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesJa_jaAllJson,
+ "wski18n/resources/ja_JA.all.json",
+ )
}
func wski18nResourcesJa_jaAllJson() (*asset, error) {
- bytes, err := wski18nResourcesJa_jaAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesJa_jaAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/ja_JA.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/ja_JA.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
var _wski18nResourcesKo_krAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")
func wski18nResourcesKo_krAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesKo_krAllJson,
- "wski18n/resources/ko_KR.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesKo_krAllJson,
+ "wski18n/resources/ko_KR.all.json",
+ )
}
func wski18nResourcesKo_krAllJson() (*asset, error) {
- bytes, err := wski18nResourcesKo_krAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesKo_krAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/ko_KR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/ko_KR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
var _wski18nResourcesPt_brAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")
func wski18nResourcesPt_brAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesPt_brAllJson,
- "wski18n/resources/pt_BR.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesPt_brAllJson,
+ "wski18n/resources/pt_BR.all.json",
+ )
}
func wski18nResourcesPt_brAllJson() (*asset, error) {
- bytes, err := wski18nResourcesPt_brAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesPt_brAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/pt_BR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/pt_BR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
var _wski18nResourcesZh_hansAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")
func wski18nResourcesZh_hansAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesZh_hansAllJson,
- "wski18n/resources/zh_Hans.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesZh_hansAllJson,
+ "wski18n/resources/zh_Hans.all.json",
+ )
}
func wski18nResourcesZh_hansAllJson() (*asset, error) {
- bytes, err := wski18nResourcesZh_hansAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesZh_hansAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/zh_Hans.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/zh_Hans.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
var _wski18nResourcesZh_hantAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")
func wski18nResourcesZh_hantAllJsonBytes() ([]byte, error) {
- return bindataRead(
- _wski18nResourcesZh_hantAllJson,
- "wski18n/resources/zh_Hant.all.json",
- )
+ return bindataRead(
+ _wski18nResourcesZh_hantAllJson,
+ "wski18n/resources/zh_Hant.all.json",
+ )
}
func wski18nResourcesZh_hantAllJson() (*asset, error) {
- bytes, err := wski18nResourcesZh_hantAllJsonBytes()
- if err != nil {
- return nil, err
- }
+ bytes, err := wski18nResourcesZh_hantAllJsonBytes()
+ if err != nil {
+ return nil, err
+ }
- info := bindataFileInfo{name: "wski18n/resources/zh_Hant.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
- a := &asset{bytes: bytes, info: info}
- return a, nil
+ info := bindataFileInfo{name: "wski18n/resources/zh_Hant.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1510603210, 0)}
+ a := &asset{bytes: bytes, info: info}
+ return a, nil
}
// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
- cannonicalName := strings.Replace(name, "\\", "/", -1)
- if f, ok := _bindata[cannonicalName]; ok {
- a, err := f()
- if err != nil {
- return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
- }
- return a.bytes, nil
- }
- return nil, fmt.Errorf("Asset %s not found", name)
+ cannonicalName := strings.Replace(name, "\\", "/", -1)
+ if f, ok := _bindata[cannonicalName]; ok {
+ a, err := f()
+ if err != nil {
+ return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+ }
+ return a.bytes, nil
+ }
+ return nil, fmt.Errorf("Asset %s not found", name)
}
// MustAsset is like Asset but panics when Asset would return an error.
// It simplifies safe initialization of global variables.
func MustAsset(name string) []byte {
- a, err := Asset(name)
- if err != nil {
- panic("asset: Asset(" + name + "): " + err.Error())
- }
+ a, err := Asset(name)
+ if err != nil {
+ panic("asset: Asset(" + name + "): " + err.Error())
+ }
- return a
+ return a
}
// AssetInfo loads and returns the asset info for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func AssetInfo(name string) (os.FileInfo, error) {
- cannonicalName := strings.Replace(name, "\\", "/", -1)
- if f, ok := _bindata[cannonicalName]; ok {
- a, err := f()
- if err != nil {
- return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
- }
- return a.info, nil
- }
- return nil, fmt.Errorf("AssetInfo %s not found", name)
+ cannonicalName := strings.Replace(name, "\\", "/", -1)
+ if f, ok := _bindata[cannonicalName]; ok {
+ a, err := f()
+ if err != nil {
+ return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+ }
+ return a.info, nil
+ }
+ return nil, fmt.Errorf("AssetInfo %s not found", name)
}
// AssetNames returns the names of the assets.
func AssetNames() []string {
- names := make([]string, 0, len(_bindata))
- for name := range _bindata {
- names = append(names, name)
- }
- return names
+ names := make([]string, 0, len(_bindata))
+ for name := range _bindata {
+ names = append(names, name)
+ }
+ return names
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
- "wski18n/resources/de_DE.all.json": wski18nResourcesDe_deAllJson,
- "wski18n/resources/en_US.all.json": wski18nResourcesEn_usAllJson,
- "wski18n/resources/es_ES.all.json": wski18nResourcesEs_esAllJson,
- "wski18n/resources/fr_FR.all.json": wski18nResourcesFr_frAllJson,
- "wski18n/resources/it_IT.all.json": wski18nResourcesIt_itAllJson,
- "wski18n/resources/ja_JA.all.json": wski18nResourcesJa_jaAllJson,
- "wski18n/resources/ko_KR.all.json": wski18nResourcesKo_krAllJson,
- "wski18n/resources/pt_BR.all.json": wski18nResourcesPt_brAllJson,
- "wski18n/resources/zh_Hans.all.json": wski18nResourcesZh_hansAllJson,
- "wski18n/resources/zh_Hant.all.json": wski18nResourcesZh_hantAllJson,
+ "wski18n/resources/de_DE.all.json": wski18nResourcesDe_deAllJson,
+ "wski18n/resources/en_US.all.json": wski18nResourcesEn_usAllJson,
+ "wski18n/resources/es_ES.all.json": wski18nResourcesEs_esAllJson,
+ "wski18n/resources/fr_FR.all.json": wski18nResourcesFr_frAllJson,
+ "wski18n/resources/it_IT.all.json": wski18nResourcesIt_itAllJson,
+ "wski18n/resources/ja_JA.all.json": wski18nResourcesJa_jaAllJson,
+ "wski18n/resources/ko_KR.all.json": wski18nResourcesKo_krAllJson,
+ "wski18n/resources/pt_BR.all.json": wski18nResourcesPt_brAllJson,
+ "wski18n/resources/zh_Hans.all.json": wski18nResourcesZh_hansAllJson,
+ "wski18n/resources/zh_Hant.all.json": wski18nResourcesZh_hantAllJson,
}
// AssetDir returns the file names below a certain
@@ -372,92 +372,92 @@ var _bindata = map[string]func() (*asset, error){
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
- node := _bintree
- if len(name) != 0 {
- cannonicalName := strings.Replace(name, "\\", "/", -1)
- pathList := strings.Split(cannonicalName, "/")
- for _, p := range pathList {
- node = node.Children[p]
- if node == nil {
- return nil, fmt.Errorf("Asset %s not found", name)
- }
- }
- }
- if node.Func != nil {
- return nil, fmt.Errorf("Asset %s not found", name)
- }
- rv := make([]string, 0, len(node.Children))
- for childName := range node.Children {
- rv = append(rv, childName)
- }
- return rv, nil
+ node := _bintree
+ if len(name) != 0 {
+ cannonicalName := strings.Replace(name, "\\", "/", -1)
+ pathList := strings.Split(cannonicalName, "/")
+ for _, p := range pathList {
+ node = node.Children[p]
+ if node == nil {
+ return nil, fmt.Errorf("Asset %s not found", name)
+ }
+ }
+ }
+ if node.Func != nil {
+ return nil, fmt.Errorf("Asset %s not found", name)
+ }
+ rv := make([]string, 0, len(node.Children))
+ for childName := range node.Children {
+ rv = append(rv, childName)
+ }
+ return rv, nil
}
type bintree struct {
- Func func() (*asset, error)
- Children map[string]*bintree
+ Func func() (*asset, error)
+ Children map[string]*bintree
}
+
var _bintree = &bintree{nil, map[string]*bintree{
- "wski18n": &bintree{nil, map[string]*bintree{
- "resources": &bintree{nil, map[string]*bintree{
- "de_DE.all.json": &bintree{wski18nResourcesDe_deAllJson, map[string]*bintree{}},
- "en_US.all.json": &bintree{wski18nResourcesEn_usAllJson, map[string]*bintree{}},
- "es_ES.all.json": &bintree{wski18nResourcesEs_esAllJson, map[string]*bintree{}},
- "fr_FR.all.json": &bintree{wski18nResourcesFr_frAllJson, map[string]*bintree{}},
- "it_IT.all.json": &bintree{wski18nResourcesIt_itAllJson, map[string]*bintree{}},
- "ja_JA.all.json": &bintree{wski18nResourcesJa_jaAllJson, map[string]*bintree{}},
- "ko_KR.all.json": &bintree{wski18nResourcesKo_krAllJson, map[string]*bintree{}},
- "pt_BR.all.json": &bintree{wski18nResourcesPt_brAllJson, map[string]*bintree{}},
- "zh_Hans.all.json": &bintree{wski18nResourcesZh_hansAllJson, map[string]*bintree{}},
- "zh_Hant.all.json": &bintree{wski18nResourcesZh_hantAllJson, map[string]*bintree{}},
- }},
- }},
+ "wski18n": {nil, map[string]*bintree{
+ "resources": {nil, map[string]*bintree{
+ "de_DE.all.json": {wski18nResourcesDe_deAllJson, map[string]*bintree{}},
+ "en_US.all.json": {wski18nResourcesEn_usAllJson, map[string]*bintree{}},
+ "es_ES.all.json": {wski18nResourcesEs_esAllJson, map[string]*bintree{}},
+ "fr_FR.all.json": {wski18nResourcesFr_frAllJson, map[string]*bintree{}},
+ "it_IT.all.json": {wski18nResourcesIt_itAllJson, map[string]*bintree{}},
+ "ja_JA.all.json": {wski18nResourcesJa_jaAllJson, map[string]*bintree{}},
+ "ko_KR.all.json": {wski18nResourcesKo_krAllJson, map[string]*bintree{}},
+ "pt_BR.all.json": {wski18nResourcesPt_brAllJson, map[string]*bintree{}},
+ "zh_Hans.all.json": {wski18nResourcesZh_hansAllJson, map[string]*bintree{}},
+ "zh_Hant.all.json": {wski18nResourcesZh_hantAllJson, map[string]*bintree{}},
+ }},
+ }},
}}
// RestoreAsset restores an asset under the given directory
func RestoreAsset(dir, name string) error {
- data, err := Asset(name)
- if err != nil {
- return err
- }
- info, err := AssetInfo(name)
- if err != nil {
- return err
- }
- err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
- if err != nil {
- return err
- }
- err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
- if err != nil {
- return err
- }
- err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
- if err != nil {
- return err
- }
- return nil
+ data, err := Asset(name)
+ if err != nil {
+ return err
+ }
+ info, err := AssetInfo(name)
+ if err != nil {
+ return err
+ }
+ err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+ if err != nil {
+ return err
+ }
+ err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+ if err != nil {
+ return err
+ }
+ err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+ if err != nil {
+ return err
+ }
+ return nil
}
// RestoreAssets restores an asset under the given directory recursively
func RestoreAssets(dir, name string) error {
- children, err := AssetDir(name)
- // File
- if err != nil {
- return RestoreAsset(dir, name)
- }
- // Dir
- for _, child := range children {
- err = RestoreAssets(dir, filepath.Join(name, child))
- if err != nil {
- return err
- }
- }
- return nil
+ children, err := AssetDir(name)
+ // File
+ if err != nil {
+ return RestoreAsset(dir, name)
+ }
+ // Dir
+ for _, child := range children {
+ err = RestoreAssets(dir, filepath.Join(name, child))
+ if err != nil {
+ return err
+ }
+ }
+ return nil
}
func _filePath(dir, name string) string {
- cannonicalName := strings.Replace(name, "\\", "/", -1)
- return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+ cannonicalName := strings.Replace(name, "\\", "/", -1)
+ return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
}
-
--
To stop receiving notification emails like this one, please contact
csantanapr@apache.org.