commands/property.go - openwhisk-cli - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package commands

 import (
 	"errors"
 	"fmt"
 	"os"

 	"github.com/fatih/color"
 	"github.com/mitchellh/go-homedir"
 	"github.com/spf13/cobra"

 	"github.com/apache/incubator-openwhisk-cli/wski18n"
 	"github.com/apache/incubator-openwhisk-client-go/whisk"
 )

 var Properties struct {
 	Cert       string
 	Key        string
 	Auth       string
 	APIHost    string
 	APIVersion string
 	APIBuild   string
 	APIBuildNo string
 	CLIVersion string
 	Namespace  string
 	PropsFile  string
 }

 const DefaultCert string = ""
 const DefaultKey string = ""
 const DefaultAuth string = ""
 const DefaultAPIHost string = ""
 const DefaultAPIVersion string = "v1"
 const DefaultAPIBuild string = ""
 const DefaultAPIBuildNo string = ""
 const DefaultNamespace string = "_"
 const DefaultPropsFile string = "~/.wskprops"

 var propertyCmd = &cobra.Command{
 	Use:   "property",
 	Short: wski18n.T("work with whisk properties"),
 }

 //
 // Set one or more openwhisk property values
 //
 var propertySetCmd = &cobra.Command{
 	Use:           "set",
 	Short:         wski18n.T("set property"),
 	SilenceUsage:  true,
 	SilenceErrors: true,
 	PreRunE:       SetupClientConfig,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		var okMsg string = ""
 		var werr *whisk.WskError = nil

 		// get current props
 		props, err := ReadProps(Properties.PropsFile)
 		if err != nil {
 			whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
 			errStr := wski18n.T("Unable to set the property value: {{.err}}", map[string]interface{}{"err": err})
 			werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 			return werr
 		}

 		// read in each flag, update if necessary
 		if cert := Flags.Global.Cert; len(cert) > 0 {
 			props["CERT"] = cert
 			Client.Config.Cert = cert
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} client cert set. Run 'wsk property get --cert' to see the new value.\n",
 					map[string]interface{}{"ok": color.GreenString("ok:")}))
 		}

 		if key := Flags.Global.Key; len(key) > 0 {
 			props["KEY"] = key
 			Client.Config.Key = key
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} client key set. Run 'wsk property get --key' to see the new value.\n",
 					map[string]interface{}{"ok": color.GreenString("ok:")}))
 		}

 		if auth := Flags.Global.Auth; len(auth) > 0 {
 			props["AUTH"] = auth
 			Client.Config.AuthToken = auth
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} whisk auth set. Run 'wsk property get --auth' to see the new value.\n",
 					map[string]interface{}{"ok": color.GreenString("ok:")}))
 		}

 		if apiHost := Flags.property.apihostSet; len(apiHost) > 0 {
 			baseURL, err := whisk.GetURLBase(apiHost, DefaultOpenWhiskApiPath)

 			if err != nil {
 				// Not aborting now.  Subsequent commands will result in error
 				whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) error: %s", apiHost, DefaultOpenWhiskApiPath, err)
 				errStr := fmt.Sprintf(
 					wski18n.T("Unable to set API host value; the API host value '{{.apihost}}' is invalid: {{.err}}",
 						map[string]interface{}{"apihost": apiHost, "err": err}))
 				werr = whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
 					whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
 			} else {
 				props["APIHOST"] = apiHost
 				Client.Config.BaseURL = baseURL
 				okMsg += fmt.Sprintf(
 					wski18n.T("{{.ok}} whisk API host set to {{.host}}\n",
 						map[string]interface{}{"ok": color.GreenString("ok:"), "host": boldString(apiHost)}))
 			}
 		}

 		if apiVersion := Flags.property.apiversionSet; len(apiVersion) > 0 {
 			props["APIVERSION"] = apiVersion
 			Client.Config.Version = apiVersion
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} whisk API version set to {{.version}}\n",
 					map[string]interface{}{"ok": color.GreenString("ok:"), "version": boldString(apiVersion)}))
 		}

 		if namespace := Flags.property.namespaceSet; len(namespace) > 0 {
 			namespaces, _, err := Client.Namespaces.List()
 			if err != nil {
 				whisk.Debug(whisk.DbgError, "Client.Namespaces.List() failed: %s\n", err)
 				errStr := fmt.Sprintf(
 					wski18n.T("Authenticated user does not have namespace '{{.name}}'; set command failed: {{.err}}",
 						map[string]interface{}{"name": namespace, "err": err}))
 				werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 			} else {
 				whisk.Debug(whisk.DbgInfo, "Validating namespace '%s' is in user namespace list %#v\n", namespace, namespaces)
 				var validNamespace bool
 				for _, ns := range namespaces {
 					if ns.Name == namespace {
 						whisk.Debug(whisk.DbgInfo, "Namespace '%s' is valid\n", namespace)
 						validNamespace = true
 					}
 				}
 				if !validNamespace {
 					whisk.Debug(whisk.DbgError, "Namespace '%s' is not in the list of entitled namespaces\n", namespace)
 					errStr := fmt.Sprintf(
 						wski18n.T("Namespace '{{.name}}' is not in the list of entitled namespaces",
 							map[string]interface{}{"name": namespace}))
 					werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 				} else {
 					props["NAMESPACE"] = namespace
 					okMsg += fmt.Sprintf(
 						wski18n.T("{{.ok}} whisk namespace set to {{.name}}\n",
 							map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(namespace)}))
 				}
 			}
 		}

 		err = WriteProps(Properties.PropsFile, props)
 		if err != nil {
 			whisk.Debug(whisk.DbgError, "writeProps(%s, %#v) failed: %s\n", Properties.PropsFile, props, err)
 			errStr := fmt.Sprintf(
 				wski18n.T("Unable to set the property value(s): {{.err}}",
 					map[string]interface{}{"err": err}))
 			werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 		} else {
 			fmt.Fprintf(color.Output, okMsg)
 		}

 		if werr != nil {
 			return werr
 		}

 		return nil
 	},
 }

 var propertyUnsetCmd = &cobra.Command{
 	Use:           "unset",
 	Short:         wski18n.T("unset property"),
 	SilenceUsage:  true,
 	SilenceErrors: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		var okMsg string = ""
 		props, err := ReadProps(Properties.PropsFile)
 		if err != nil {
 			whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
 			errStr := fmt.Sprintf(
 				wski18n.T("Unable to unset the property value: {{.err}}",
 					map[string]interface{}{"err": err}))
 			werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 			return werr
 		}

 		// read in each flag, update if necessary

 		if Flags.property.cert {
 			delete(props, "CERT")
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} client cert unset.\n",
 					map[string]interface{}{"ok": color.GreenString("ok:")}))
 		}

 		if Flags.property.key {
 			delete(props, "KEY")
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} client key unset.\n",
 					map[string]interface{}{"ok": color.GreenString("ok:")}))
 		}

 		if Flags.property.auth {
 			delete(props, "AUTH")
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} whisk auth unset.\n",
 					map[string]interface{}{"ok": color.GreenString("ok:")}))
 		}

 		if Flags.property.namespace {
 			delete(props, "NAMESPACE")
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} whisk namespace unset",
 					map[string]interface{}{"ok": color.GreenString("ok:")}))
 			if len(DefaultNamespace) > 0 {
 				okMsg += fmt.Sprintf(
 					wski18n.T("; the default value of {{.default}} will be used.\n",
 						map[string]interface{}{"default": boldString(DefaultNamespace)}))
 			} else {
 				okMsg += fmt.Sprint(
 					wski18n.T("; there is no default value that can be used.\n"))
 			}
 		}

 		if Flags.property.apihost {
 			delete(props, "APIHOST")
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} whisk API host unset.\n",
 					map[string]interface{}{"ok": color.GreenString("ok:")}))
 		}

 		if Flags.property.apiversion {
 			delete(props, "APIVERSION")
 			okMsg += fmt.Sprintf(
 				wski18n.T("{{.ok}} whisk API version unset",
 					map[string]interface{}{"ok": color.GreenString("ok:")}))
 			if len(DefaultAPIVersion) > 0 {
 				okMsg += fmt.Sprintf(
 					wski18n.T("; the default value of {{.default}} will be used.\n",
 						map[string]interface{}{"default": boldString(DefaultAPIVersion)}))
 			} else {
 				okMsg += fmt.Sprint(
 					wski18n.T("; there is no default value that can be used.\n"))
 			}
 		}

 		err = WriteProps(Properties.PropsFile, props)
 		if err != nil {
 			whisk.Debug(whisk.DbgError, "writeProps(%s, %#v) failed: %s\n", Properties.PropsFile, props, err)
 			errStr := fmt.Sprintf(
 				wski18n.T("Unable to unset the property value: {{.err}}",
 					map[string]interface{}{"err": err}))
 			werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 			return werr
 		}

 		fmt.Fprintf(color.Output, okMsg)
 		if err = loadProperties(); err != nil {
 			whisk.Debug(whisk.DbgError, "loadProperties() failed: %s\n", err)
 		}
 		return nil
 	},
 }

 var propertyGetCmd = &cobra.Command{
 	Use:           "get",
 	Short:         wski18n.T("get property"),
 	SilenceUsage:  true,
 	SilenceErrors: true,
 	PreRunE:       SetupClientConfig,
 	RunE: func(cmd *cobra.Command, args []string) error {

 		// If no property is explicitly specified, default to all properties
 		if !(Flags.property.all || Flags.property.cert ||
 			Flags.property.key || Flags.property.auth ||
 			Flags.property.apiversion || Flags.property.cliversion ||
 			Flags.property.namespace || Flags.property.apibuild ||
 			Flags.property.apihost || Flags.property.apibuildno) {
 			Flags.property.all = true
 		}

 		if Flags.property.all || Flags.property.cert {
 			fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("client cert"), boldString(Properties.Cert))
 		}

 		if Flags.property.all || Flags.property.key {
 			fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("Client key"), boldString(Properties.Key))
 		}

 		if Flags.property.all || Flags.property.auth {
 			fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk auth"), boldString(Properties.Auth))
 		}

 		if Flags.property.all || Flags.property.apihost {
 			fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk API host"), boldString(Properties.APIHost))
 		}

 		if Flags.property.all || Flags.property.apiversion {
 			fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk API version"), boldString(Properties.APIVersion))
 		}

 		if Flags.property.all || Flags.property.namespace {
 			fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk namespace"), boldString(Properties.Namespace))
 		}

 		if Flags.property.all || Flags.property.cliversion {
 			fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk CLI version"), boldString(Properties.CLIVersion))
 		}

 		if Flags.property.all || Flags.property.apibuild || Flags.property.apibuildno {
 			info, _, err := Client.Info.Get()
 			if err != nil {
 				whisk.Debug(whisk.DbgError, "Client.Info.Get() failed: %s\n", err)
 				info = &whisk.Info{}
 				info.Build = wski18n.T("Unknown")
 				info.BuildNo = wski18n.T("Unknown")
 			}
 			if Flags.property.all || Flags.property.apibuild {
 				fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk API build"), boldString(info.Build))
 			}
 			if Flags.property.all || Flags.property.apibuildno {
 				fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk API build number"), boldString(info.BuildNo))
 			}
 			if err != nil {
 				errStr := fmt.Sprintf(
 					wski18n.T("Unable to obtain API build information: {{.err}}",
 						map[string]interface{}{"err": err}))
 				werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 				return werr
 			}
 		}

 		return nil
 	},
 }

 func init() {
 	propertyCmd.AddCommand(
 		propertySetCmd,
 		propertyUnsetCmd,
 		propertyGetCmd,
 	)

 	// need to set property flags as booleans instead of strings... perhaps with boolApihost...
 	propertyGetCmd.Flags().BoolVar(&Flags.property.cert, "cert", false, wski18n.T("client cert"))
 	propertyGetCmd.Flags().BoolVar(&Flags.property.key, "key", false, wski18n.T("client key"))
 	propertyGetCmd.Flags().BoolVar(&Flags.property.auth, "auth", false, wski18n.T("authorization key"))
 	propertyGetCmd.Flags().BoolVar(&Flags.property.apihost, "apihost", false, wski18n.T("whisk API host"))
 	propertyGetCmd.Flags().BoolVar(&Flags.property.apiversion, "apiversion", false, wski18n.T("whisk API version"))
 	propertyGetCmd.Flags().BoolVar(&Flags.property.apibuild, "apibuild", false, wski18n.T("whisk API build version"))
 	propertyGetCmd.Flags().BoolVar(&Flags.property.apibuildno, "apibuildno", false, wski18n.T("whisk API build number"))
 	propertyGetCmd.Flags().BoolVar(&Flags.property.cliversion, "cliversion", false, wski18n.T("whisk CLI version"))
 	propertyGetCmd.Flags().BoolVar(&Flags.property.namespace, "namespace", false, wski18n.T("whisk namespace"))
 	propertyGetCmd.Flags().BoolVar(&Flags.property.all, "all", false, wski18n.T("all properties"))

 	propertySetCmd.Flags().StringVarP(&Flags.Global.Auth, "auth", "u", "", wski18n.T("authorization `KEY`"))
 	propertySetCmd.Flags().StringVar(&Flags.Global.Cert, "cert", "", wski18n.T("client cert"))
 	propertySetCmd.Flags().StringVar(&Flags.Global.Key, "key", "", wski18n.T("client key"))
 	propertySetCmd.Flags().StringVar(&Flags.property.apihostSet, "apihost", "", wski18n.T("whisk API `HOST`"))
 	propertySetCmd.Flags().StringVar(&Flags.property.apiversionSet, "apiversion", "", wski18n.T("whisk API `VERSION`"))
 	propertySetCmd.Flags().StringVar(&Flags.property.namespaceSet, "namespace", "", wski18n.T("whisk `NAMESPACE`"))

 	propertyUnsetCmd.Flags().BoolVar(&Flags.property.cert, "cert", false, wski18n.T("client cert"))
 	propertyUnsetCmd.Flags().BoolVar(&Flags.property.key, "key", false, wski18n.T("client key"))
 	propertyUnsetCmd.Flags().BoolVar(&Flags.property.auth, "auth", false, wski18n.T("authorization key"))
 	propertyUnsetCmd.Flags().BoolVar(&Flags.property.apihost, "apihost", false, wski18n.T("whisk API host"))
 	propertyUnsetCmd.Flags().BoolVar(&Flags.property.apiversion, "apiversion", false, wski18n.T("whisk API version"))
 	propertyUnsetCmd.Flags().BoolVar(&Flags.property.namespace, "namespace", false, wski18n.T("whisk namespace"))

 }

 func SetDefaultProperties() {
 	Properties.Key = DefaultCert
 	Properties.Cert = DefaultKey
 	Properties.Auth = DefaultAuth
 	Properties.Namespace = DefaultNamespace
 	Properties.APIHost = DefaultAPIHost
 	Properties.APIBuild = DefaultAPIBuild
 	Properties.APIBuildNo = DefaultAPIBuildNo
 	Properties.APIVersion = DefaultAPIVersion
 	Properties.PropsFile = DefaultPropsFile
 	// Properties.CLIVersion value is set from main's init()
 }

 func GetPropertiesFilePath() (propsFilePath string, werr error) {
 	var envExists bool

 	// WSK_CONFIG_FILE environment variable overrides the default properties file path
 	// NOTE: If this variable is set to an empty string or non-existent/unreadable file
 	// - any existing $HOME/.wskprops is ignored
 	// - a default configuration is used
 	if propsFilePath, envExists = os.LookupEnv("WSK_CONFIG_FILE"); envExists {
 		whisk.Debug(whisk.DbgInfo, "Using properties file '%s' from WSK_CONFIG_FILE environment variable\n", propsFilePath)
 		return propsFilePath, nil
 	} else {
 		var err error

 		propsFilePath, err = homedir.Expand(Properties.PropsFile)

 		if err != nil {
 			whisk.Debug(whisk.DbgError, "homedir.Expand(%s) failed: %s\n", Properties.PropsFile, err)
 			errStr := fmt.Sprintf(
 				wski18n.T("Unable to locate properties file '{{.filename}}': {{.err}}",
 					map[string]interface{}{"filename": Properties.PropsFile, "err": err}))
 			werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 			return propsFilePath, werr
 		}

 		whisk.Debug(whisk.DbgInfo, "Using properties file home dir '%s'\n", propsFilePath)
 	}

 	return propsFilePath, nil
 }

 func loadProperties() error {
 	var err error

 	SetDefaultProperties()

 	Properties.PropsFile, err = GetPropertiesFilePath()
 	if err != nil {
 		return nil
 		//whisk.Debug(whisk.DbgError, "GetPropertiesFilePath() failed: %s\n", err)
 		//errStr := fmt.Sprintf("Unable to load the properties file: %s", err)
 		//werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 		//return werr
 	}

 	props, err := ReadProps(Properties.PropsFile)
 	if err != nil {
 		whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
 		errStr := wski18n.T("Unable to read the properties file '{{.filename}}': {{.err}}",
 			map[string]interface{}{"filename": Properties.PropsFile, "err": err})
 		werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 		return werr
 	}

 	if cert, hasProp := props["CERT"]; hasProp {
 		Properties.Cert = cert
 	}

 	if key, hasProp := props["KEY"]; hasProp {
 		Properties.Key = key
 	}

 	if authToken, hasProp := props["AUTH"]; hasProp {
 		Properties.Auth = authToken
 	}

 	if authToken := os.Getenv("WHISK_AUTH"); len(authToken) > 0 {
 		Properties.Auth = authToken
 	}

 	if apiVersion, hasProp := props["APIVERSION"]; hasProp {
 		Properties.APIVersion = apiVersion
 	}

 	if apiVersion := os.Getenv("WHISK_APIVERSION"); len(apiVersion) > 0 {
 		Properties.APIVersion = apiVersion
 	}

 	if apiHost, hasProp := props["APIHOST"]; hasProp {
 		Properties.APIHost = apiHost
 	}

 	if apiHost := os.Getenv("WHISK_APIHOST"); len(apiHost) > 0 {
 		Properties.APIHost = apiHost
 	}

 	if namespace, hasProp := props["NAMESPACE"]; hasProp && len(namespace) > 0 {
 		Properties.Namespace = namespace
 	}

 	if namespace := os.Getenv("WHISK_NAMESPACE"); len(namespace) > 0 {
 		Properties.Namespace = namespace
 	}

 	return nil
 }

 func parseConfigFlags(cmd *cobra.Command, args []string) error {

 	if cert := Flags.Global.Cert; len(cert) > 0 {
 		Properties.Cert = cert
 		if Client != nil {
 			Client.Config.Cert = cert
 		}
 	}

 	if key := Flags.Global.Key; len(key) > 0 {
 		Properties.Key = key
 		if Client != nil {
 			Client.Config.Key = key
 		}
 	}

 	if auth := Flags.Global.Auth; len(auth) > 0 {
 		Properties.Auth = auth
 		if Client != nil {
 			Client.Config.AuthToken = auth
 		}
 	}

 	if namespace := Flags.property.namespaceSet; len(namespace) > 0 {
 		Properties.Namespace = namespace
 		if Client != nil {
 			Client.Config.Namespace = namespace
 		}
 	}

 	if apiVersion := Flags.Global.Apiversion; len(apiVersion) > 0 {
 		Properties.APIVersion = apiVersion
 		if Client != nil {
 			Client.Config.Version = apiVersion
 		}
 	}

 	if apiHost := Flags.Global.Apihost; len(apiHost) > 0 {
 		Properties.APIHost = apiHost
 		if Client != nil {
 			Client.Config.Host = apiHost
 			baseURL, err := whisk.GetURLBase(apiHost, DefaultOpenWhiskApiPath)

 			if err != nil {
 				whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) failed: %s\n", apiHost, DefaultOpenWhiskApiPath, err)
 				errStr := wski18n.T("Invalid host address '{{.host}}': {{.err}}",
 					map[string]interface{}{"host": Properties.APIHost, "err": err})
 				werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
 				return werr
 			}
 			Client.Config.BaseURL = baseURL
 		}
 	}

 	if Flags.Global.Debug {
 		whisk.SetDebug(true)
 	}
 	if Flags.Global.Verbose {
 		whisk.SetVerbose(true)
 	}

 	return nil
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package commands

	import (
	"errors"
	"fmt"
	"os"

	"github.com/fatih/color"
	"github.com/mitchellh/go-homedir"
	"github.com/spf13/cobra"

	"github.com/apache/incubator-openwhisk-cli/wski18n"
	"github.com/apache/incubator-openwhisk-client-go/whisk"
	)

	var Properties struct {
	Cert string
	Key string
	Auth string
	APIHost string
	APIVersion string
	APIBuild string
	APIBuildNo string
	CLIVersion string
	Namespace string
	PropsFile string
	}

	const DefaultCert string = ""
	const DefaultKey string = ""
	const DefaultAuth string = ""
	const DefaultAPIHost string = ""
	const DefaultAPIVersion string = "v1"
	const DefaultAPIBuild string = ""
	const DefaultAPIBuildNo string = ""
	const DefaultNamespace string = "_"
	const DefaultPropsFile string = "~/.wskprops"

	var propertyCmd = &cobra.Command{
	Use: "property",
	Short: wski18n.T("work with whisk properties"),
	}

	//
	// Set one or more openwhisk property values
	//
	var propertySetCmd = &cobra.Command{
	Use: "set",
	Short: wski18n.T("set property"),
	SilenceUsage: true,
	SilenceErrors: true,
	PreRunE: SetupClientConfig,
	RunE: func(cmd *cobra.Command, args []string) error {
	var okMsg string = ""
	var werr *whisk.WskError = nil

	// get current props
	props, err := ReadProps(Properties.PropsFile)
	if err != nil {
	whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
	errStr := wski18n.T("Unable to set the property value: {{.err}}", map[string]interface{}{"err": err})
	werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	return werr
	}

	// read in each flag, update if necessary
	if cert := Flags.Global.Cert; len(cert) > 0 {
	props["CERT"] = cert
	Client.Config.Cert = cert
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} client cert set. Run 'wsk property get --cert' to see the new value.\n",
	map[string]interface{}{"ok": color.GreenString("ok:")}))
	}

	if key := Flags.Global.Key; len(key) > 0 {
	props["KEY"] = key
	Client.Config.Key = key
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} client key set. Run 'wsk property get --key' to see the new value.\n",
	map[string]interface{}{"ok": color.GreenString("ok:")}))
	}

	if auth := Flags.Global.Auth; len(auth) > 0 {
	props["AUTH"] = auth
	Client.Config.AuthToken = auth
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} whisk auth set. Run 'wsk property get --auth' to see the new value.\n",
	map[string]interface{}{"ok": color.GreenString("ok:")}))
	}

	if apiHost := Flags.property.apihostSet; len(apiHost) > 0 {
	baseURL, err := whisk.GetURLBase(apiHost, DefaultOpenWhiskApiPath)

	if err != nil {
	// Not aborting now. Subsequent commands will result in error
	whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) error: %s", apiHost, DefaultOpenWhiskApiPath, err)
	errStr := fmt.Sprintf(
	wski18n.T("Unable to set API host value; the API host value '{{.apihost}}' is invalid: {{.err}}",
	map[string]interface{}{"apihost": apiHost, "err": err}))
	werr = whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL,
	whisk.DISPLAY_MSG, whisk.DISPLAY_USAGE)
	} else {
	props["APIHOST"] = apiHost
	Client.Config.BaseURL = baseURL
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} whisk API host set to {{.host}}\n",
	map[string]interface{}{"ok": color.GreenString("ok:"), "host": boldString(apiHost)}))
	}
	}

	if apiVersion := Flags.property.apiversionSet; len(apiVersion) > 0 {
	props["APIVERSION"] = apiVersion
	Client.Config.Version = apiVersion
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} whisk API version set to {{.version}}\n",
	map[string]interface{}{"ok": color.GreenString("ok:"), "version": boldString(apiVersion)}))
	}

	if namespace := Flags.property.namespaceSet; len(namespace) > 0 {
	namespaces, _, err := Client.Namespaces.List()
	if err != nil {
	whisk.Debug(whisk.DbgError, "Client.Namespaces.List() failed: %s\n", err)
	errStr := fmt.Sprintf(
	wski18n.T("Authenticated user does not have namespace '{{.name}}'; set command failed: {{.err}}",
	map[string]interface{}{"name": namespace, "err": err}))
	werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	} else {
	whisk.Debug(whisk.DbgInfo, "Validating namespace '%s' is in user namespace list %#v\n", namespace, namespaces)
	var validNamespace bool
	for _, ns := range namespaces {
	if ns.Name == namespace {
	whisk.Debug(whisk.DbgInfo, "Namespace '%s' is valid\n", namespace)
	validNamespace = true
	}
	}
	if !validNamespace {
	whisk.Debug(whisk.DbgError, "Namespace '%s' is not in the list of entitled namespaces\n", namespace)
	errStr := fmt.Sprintf(
	wski18n.T("Namespace '{{.name}}' is not in the list of entitled namespaces",
	map[string]interface{}{"name": namespace}))
	werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	} else {
	props["NAMESPACE"] = namespace
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} whisk namespace set to {{.name}}\n",
	map[string]interface{}{"ok": color.GreenString("ok:"), "name": boldString(namespace)}))
	}
	}
	}

	err = WriteProps(Properties.PropsFile, props)
	if err != nil {
	whisk.Debug(whisk.DbgError, "writeProps(%s, %#v) failed: %s\n", Properties.PropsFile, props, err)
	errStr := fmt.Sprintf(
	wski18n.T("Unable to set the property value(s): {{.err}}",
	map[string]interface{}{"err": err}))
	werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	} else {
	fmt.Fprintf(color.Output, okMsg)
	}

	if werr != nil {
	return werr
	}

	return nil
	},
	}

	var propertyUnsetCmd = &cobra.Command{
	Use: "unset",
	Short: wski18n.T("unset property"),
	SilenceUsage: true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {
	var okMsg string = ""
	props, err := ReadProps(Properties.PropsFile)
	if err != nil {
	whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
	errStr := fmt.Sprintf(
	wski18n.T("Unable to unset the property value: {{.err}}",
	map[string]interface{}{"err": err}))
	werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	return werr
	}

	// read in each flag, update if necessary

	if Flags.property.cert {
	delete(props, "CERT")
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} client cert unset.\n",
	map[string]interface{}{"ok": color.GreenString("ok:")}))
	}

	if Flags.property.key {
	delete(props, "KEY")
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} client key unset.\n",
	map[string]interface{}{"ok": color.GreenString("ok:")}))
	}

	if Flags.property.auth {
	delete(props, "AUTH")
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} whisk auth unset.\n",
	map[string]interface{}{"ok": color.GreenString("ok:")}))
	}

	if Flags.property.namespace {
	delete(props, "NAMESPACE")
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} whisk namespace unset",
	map[string]interface{}{"ok": color.GreenString("ok:")}))
	if len(DefaultNamespace) > 0 {
	okMsg += fmt.Sprintf(
	wski18n.T("; the default value of {{.default}} will be used.\n",
	map[string]interface{}{"default": boldString(DefaultNamespace)}))
	} else {
	okMsg += fmt.Sprint(
	wski18n.T("; there is no default value that can be used.\n"))
	}
	}

	if Flags.property.apihost {
	delete(props, "APIHOST")
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} whisk API host unset.\n",
	map[string]interface{}{"ok": color.GreenString("ok:")}))
	}

	if Flags.property.apiversion {
	delete(props, "APIVERSION")
	okMsg += fmt.Sprintf(
	wski18n.T("{{.ok}} whisk API version unset",
	map[string]interface{}{"ok": color.GreenString("ok:")}))
	if len(DefaultAPIVersion) > 0 {
	okMsg += fmt.Sprintf(
	wski18n.T("; the default value of {{.default}} will be used.\n",
	map[string]interface{}{"default": boldString(DefaultAPIVersion)}))
	} else {
	okMsg += fmt.Sprint(
	wski18n.T("; there is no default value that can be used.\n"))
	}
	}

	err = WriteProps(Properties.PropsFile, props)
	if err != nil {
	whisk.Debug(whisk.DbgError, "writeProps(%s, %#v) failed: %s\n", Properties.PropsFile, props, err)
	errStr := fmt.Sprintf(
	wski18n.T("Unable to unset the property value: {{.err}}",
	map[string]interface{}{"err": err}))
	werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	return werr
	}

	fmt.Fprintf(color.Output, okMsg)
	if err = loadProperties(); err != nil {
	whisk.Debug(whisk.DbgError, "loadProperties() failed: %s\n", err)
	}
	return nil
	},
	}

	var propertyGetCmd = &cobra.Command{
	Use: "get",
	Short: wski18n.T("get property"),
	SilenceUsage: true,
	SilenceErrors: true,
	PreRunE: SetupClientConfig,
	RunE: func(cmd *cobra.Command, args []string) error {

	// If no property is explicitly specified, default to all properties
	if !(Flags.property.all \|\| Flags.property.cert \|\|
	Flags.property.key \|\| Flags.property.auth \|\|
	Flags.property.apiversion \|\| Flags.property.cliversion \|\|
	Flags.property.namespace \|\| Flags.property.apibuild \|\|
	Flags.property.apihost \|\| Flags.property.apibuildno) {
	Flags.property.all = true
	}

	if Flags.property.all \|\| Flags.property.cert {
	fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("client cert"), boldString(Properties.Cert))
	}

	if Flags.property.all \|\| Flags.property.key {
	fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("Client key"), boldString(Properties.Key))
	}

	if Flags.property.all \|\| Flags.property.auth {
	fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk auth"), boldString(Properties.Auth))
	}

	if Flags.property.all \|\| Flags.property.apihost {
	fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk API host"), boldString(Properties.APIHost))
	}

	if Flags.property.all \|\| Flags.property.apiversion {
	fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk API version"), boldString(Properties.APIVersion))
	}

	if Flags.property.all \|\| Flags.property.namespace {
	fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk namespace"), boldString(Properties.Namespace))
	}

	if Flags.property.all \|\| Flags.property.cliversion {
	fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk CLI version"), boldString(Properties.CLIVersion))
	}

	if Flags.property.all \|\| Flags.property.apibuild \|\| Flags.property.apibuildno {
	info, _, err := Client.Info.Get()
	if err != nil {
	whisk.Debug(whisk.DbgError, "Client.Info.Get() failed: %s\n", err)
	info = &whisk.Info{}
	info.Build = wski18n.T("Unknown")
	info.BuildNo = wski18n.T("Unknown")
	}
	if Flags.property.all \|\| Flags.property.apibuild {
	fmt.Fprintf(color.Output, "%s\t\t%s\n", wski18n.T("whisk API build"), boldString(info.Build))
	}
	if Flags.property.all \|\| Flags.property.apibuildno {
	fmt.Fprintf(color.Output, "%s\t%s\n", wski18n.T("whisk API build number"), boldString(info.BuildNo))
	}
	if err != nil {
	errStr := fmt.Sprintf(
	wski18n.T("Unable to obtain API build information: {{.err}}",
	map[string]interface{}{"err": err}))
	werr := whisk.MakeWskErrorFromWskError(errors.New(errStr), err, whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	return werr
	}
	}

	return nil
	},
	}

	func init() {
	propertyCmd.AddCommand(
	propertySetCmd,
	propertyUnsetCmd,
	propertyGetCmd,
	)

	// need to set property flags as booleans instead of strings... perhaps with boolApihost...
	propertyGetCmd.Flags().BoolVar(&Flags.property.cert, "cert", false, wski18n.T("client cert"))
	propertyGetCmd.Flags().BoolVar(&Flags.property.key, "key", false, wski18n.T("client key"))
	propertyGetCmd.Flags().BoolVar(&Flags.property.auth, "auth", false, wski18n.T("authorization key"))
	propertyGetCmd.Flags().BoolVar(&Flags.property.apihost, "apihost", false, wski18n.T("whisk API host"))
	propertyGetCmd.Flags().BoolVar(&Flags.property.apiversion, "apiversion", false, wski18n.T("whisk API version"))
	propertyGetCmd.Flags().BoolVar(&Flags.property.apibuild, "apibuild", false, wski18n.T("whisk API build version"))
	propertyGetCmd.Flags().BoolVar(&Flags.property.apibuildno, "apibuildno", false, wski18n.T("whisk API build number"))
	propertyGetCmd.Flags().BoolVar(&Flags.property.cliversion, "cliversion", false, wski18n.T("whisk CLI version"))
	propertyGetCmd.Flags().BoolVar(&Flags.property.namespace, "namespace", false, wski18n.T("whisk namespace"))
	propertyGetCmd.Flags().BoolVar(&Flags.property.all, "all", false, wski18n.T("all properties"))

	propertySetCmd.Flags().StringVarP(&Flags.Global.Auth, "auth", "u", "", wski18n.T("authorization `KEY`"))
	propertySetCmd.Flags().StringVar(&Flags.Global.Cert, "cert", "", wski18n.T("client cert"))
	propertySetCmd.Flags().StringVar(&Flags.Global.Key, "key", "", wski18n.T("client key"))
	propertySetCmd.Flags().StringVar(&Flags.property.apihostSet, "apihost", "", wski18n.T("whisk API `HOST`"))
	propertySetCmd.Flags().StringVar(&Flags.property.apiversionSet, "apiversion", "", wski18n.T("whisk API `VERSION`"))
	propertySetCmd.Flags().StringVar(&Flags.property.namespaceSet, "namespace", "", wski18n.T("whisk `NAMESPACE`"))

	propertyUnsetCmd.Flags().BoolVar(&Flags.property.cert, "cert", false, wski18n.T("client cert"))
	propertyUnsetCmd.Flags().BoolVar(&Flags.property.key, "key", false, wski18n.T("client key"))
	propertyUnsetCmd.Flags().BoolVar(&Flags.property.auth, "auth", false, wski18n.T("authorization key"))
	propertyUnsetCmd.Flags().BoolVar(&Flags.property.apihost, "apihost", false, wski18n.T("whisk API host"))
	propertyUnsetCmd.Flags().BoolVar(&Flags.property.apiversion, "apiversion", false, wski18n.T("whisk API version"))
	propertyUnsetCmd.Flags().BoolVar(&Flags.property.namespace, "namespace", false, wski18n.T("whisk namespace"))

	}

	func SetDefaultProperties() {
	Properties.Key = DefaultCert
	Properties.Cert = DefaultKey
	Properties.Auth = DefaultAuth
	Properties.Namespace = DefaultNamespace
	Properties.APIHost = DefaultAPIHost
	Properties.APIBuild = DefaultAPIBuild
	Properties.APIBuildNo = DefaultAPIBuildNo
	Properties.APIVersion = DefaultAPIVersion
	Properties.PropsFile = DefaultPropsFile
	// Properties.CLIVersion value is set from main's init()
	}

	func GetPropertiesFilePath() (propsFilePath string, werr error) {
	var envExists bool

	// WSK_CONFIG_FILE environment variable overrides the default properties file path
	// NOTE: If this variable is set to an empty string or non-existent/unreadable file
	// - any existing $HOME/.wskprops is ignored
	// - a default configuration is used
	if propsFilePath, envExists = os.LookupEnv("WSK_CONFIG_FILE"); envExists {
	whisk.Debug(whisk.DbgInfo, "Using properties file '%s' from WSK_CONFIG_FILE environment variable\n", propsFilePath)
	return propsFilePath, nil
	} else {
	var err error

	propsFilePath, err = homedir.Expand(Properties.PropsFile)

	if err != nil {
	whisk.Debug(whisk.DbgError, "homedir.Expand(%s) failed: %s\n", Properties.PropsFile, err)
	errStr := fmt.Sprintf(
	wski18n.T("Unable to locate properties file '{{.filename}}': {{.err}}",
	map[string]interface{}{"filename": Properties.PropsFile, "err": err}))
	werr = whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	return propsFilePath, werr
	}

	whisk.Debug(whisk.DbgInfo, "Using properties file home dir '%s'\n", propsFilePath)
	}

	return propsFilePath, nil
	}

	func loadProperties() error {
	var err error

	SetDefaultProperties()

	Properties.PropsFile, err = GetPropertiesFilePath()
	if err != nil {
	return nil
	//whisk.Debug(whisk.DbgError, "GetPropertiesFilePath() failed: %s\n", err)
	//errStr := fmt.Sprintf("Unable to load the properties file: %s", err)
	//werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	//return werr
	}

	props, err := ReadProps(Properties.PropsFile)
	if err != nil {
	whisk.Debug(whisk.DbgError, "readProps(%s) failed: %s\n", Properties.PropsFile, err)
	errStr := wski18n.T("Unable to read the properties file '{{.filename}}': {{.err}}",
	map[string]interface{}{"filename": Properties.PropsFile, "err": err})
	werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	return werr
	}

	if cert, hasProp := props["CERT"]; hasProp {
	Properties.Cert = cert
	}

	if key, hasProp := props["KEY"]; hasProp {
	Properties.Key = key
	}

	if authToken, hasProp := props["AUTH"]; hasProp {
	Properties.Auth = authToken
	}

	if authToken := os.Getenv("WHISK_AUTH"); len(authToken) > 0 {
	Properties.Auth = authToken
	}

	if apiVersion, hasProp := props["APIVERSION"]; hasProp {
	Properties.APIVersion = apiVersion
	}

	if apiVersion := os.Getenv("WHISK_APIVERSION"); len(apiVersion) > 0 {
	Properties.APIVersion = apiVersion
	}

	if apiHost, hasProp := props["APIHOST"]; hasProp {
	Properties.APIHost = apiHost
	}

	if apiHost := os.Getenv("WHISK_APIHOST"); len(apiHost) > 0 {
	Properties.APIHost = apiHost
	}

	if namespace, hasProp := props["NAMESPACE"]; hasProp && len(namespace) > 0 {
	Properties.Namespace = namespace
	}

	if namespace := os.Getenv("WHISK_NAMESPACE"); len(namespace) > 0 {
	Properties.Namespace = namespace
	}

	return nil
	}

	func parseConfigFlags(cmd *cobra.Command, args []string) error {

	if cert := Flags.Global.Cert; len(cert) > 0 {
	Properties.Cert = cert
	if Client != nil {
	Client.Config.Cert = cert
	}
	}

	if key := Flags.Global.Key; len(key) > 0 {
	Properties.Key = key
	if Client != nil {
	Client.Config.Key = key
	}
	}

	if auth := Flags.Global.Auth; len(auth) > 0 {
	Properties.Auth = auth
	if Client != nil {
	Client.Config.AuthToken = auth
	}
	}

	if namespace := Flags.property.namespaceSet; len(namespace) > 0 {
	Properties.Namespace = namespace
	if Client != nil {
	Client.Config.Namespace = namespace
	}
	}

	if apiVersion := Flags.Global.Apiversion; len(apiVersion) > 0 {
	Properties.APIVersion = apiVersion
	if Client != nil {
	Client.Config.Version = apiVersion
	}
	}

	if apiHost := Flags.Global.Apihost; len(apiHost) > 0 {
	Properties.APIHost = apiHost
	if Client != nil {
	Client.Config.Host = apiHost
	baseURL, err := whisk.GetURLBase(apiHost, DefaultOpenWhiskApiPath)

	if err != nil {
	whisk.Debug(whisk.DbgError, "whisk.GetURLBase(%s, %s) failed: %s\n", apiHost, DefaultOpenWhiskApiPath, err)
	errStr := wski18n.T("Invalid host address '{{.host}}': {{.err}}",
	map[string]interface{}{"host": Properties.APIHost, "err": err})
	werr := whisk.MakeWskError(errors.New(errStr), whisk.EXIT_CODE_ERR_GENERAL, whisk.DISPLAY_MSG, whisk.NO_DISPLAY_USAGE)
	return werr
	}
	Client.Config.BaseURL = baseURL
	}
	}

	if Flags.Global.Debug {
	whisk.SetDebug(true)
	}
	if Flags.Global.Verbose {
	whisk.SetVerbose(true)
	}

	return nil
	}