openwhisk-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From csantan...@apache.org
Subject [incubator-openwhisk-client-go] 02/02: Format source code
Date Sun, 28 Jan 2018 14:59:14 GMT
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 <jwdubee@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.

Mime
View raw message