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:14 UTC
[incubator-openwhisk-client-go] 02/02: Format source code
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.