diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..1bf987c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+*.js
+javascript/
+wsk
+scripts
+Godeps/_workspace
diff --git a/.idea/libraries/GOPATH__openwhisk_cli_.xml b/.idea/libraries/GOPATH__openwhisk_cli_.xml
new file mode 100644
index 0000000..a0e31a5
--- /dev/null
+++ b/.idea/libraries/GOPATH__openwhisk_cli_.xml
@@ -0,0 +1,18 @@
+<component name="libraryTable">
+  <library name="GOPATH &lt;openwhisk-cli&gt;">
+    <CLASSES>
+      <root url="file://$USER_HOME$/go/src/gopkg.in" />
+      <root url="file://$USER_HOME$/go/src/github.com" />
+      <root url="file://$USER_HOME$/go/src/golang.org" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES>
+      <root url="file://$USER_HOME$/go/src/gopkg.in" />
+      <root url="file://$USER_HOME$/go/src/github.com" />
+      <root url="file://$USER_HOME$/go/src/golang.org" />
+    </SOURCES>
+    <excluded>
+      <root url="file://$PROJECT_DIR$" />
+    </excluded>
+  </library>
+</component>
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..99168e9
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,34 @@
+# Contributing to go-whisk-cli
+
+## Proposing new features
+
+If you would like to implement a new feature, please [raise an issue](https://github.ibm.com/BlueMix-Fabric/go-whisk-cli) before sending a pull request so the feature can be discussed.
+This is to avoid you spending your valuable time working on a feature that the project developers are not willing to accept into the code base.
+
+## Fixing bugs
+
+If you would like to fix a bug, please [raise an issue](https://github.ibm.com/BlueMix-Fabric/go-whisk-cli) before sending a pull request so it can be discussed.
+If the fix is trivial or non controversial then this is not usually necessary.
+
+## Merge approval
+
+The project maintainers use LGTM (Looks Good To Me) in comments on the code review to
+indicate acceptance. A change requires LGTMs from two of the maintainers of each
+component affected.
+
+## Communication
+Please use [Slack channel #whisk-users](https://cloudplatform.slack.com/messages/whisk_cli).
+## Setup
+Project was written with `Go v1.5`.  It has a dependency on [go-whisk](https://github.ibm.com/BlueMix-Fabric/go-whisk), which has to be manually resolved (because of GHE).
+
+## Testing
+
+This repository needs unit tests.
+
+Please provide information that helps the developer test any changes they make before submitting.
+
+Should pass the cli integration test defined in the [main whisk project](https://github.rtp.raleigh.ibm.com/whisk-development/openwhisk/blob/master/tests/src/common/WskCli.java).
+
+## Coding style guidelines
+
+Use idomatic go.  (try to) Document exported functions.
diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index 16f6be8..9c0fd26 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -75,11 +75,11 @@
 		},
 		{
 			"ImportPath": "github.com/openwhisk/openwhisk-client-go/whisk",
-			"Rev": "c91a7494986d5f45b62003a2ab19bb0fd8ddeb7f"
+			"Rev": "5c216065673c15e35e0baa8feca9b986a6b73517"
 		},
         {
             "ImportPath": "github.com/openwhisk/openwhisk-client-go/wski18n",
-            "Rev": "c91a7494986d5f45b62003a2ab19bb0fd8ddeb7f"
+            "Rev": "5c216065673c15e35e0baa8feca9b986a6b73517"
         }
 	]
-}
\ No newline at end of file
+}
diff --git a/commands/property.go b/commands/property.go
index 0ec5f52..ed6b49e 100644
--- a/commands/property.go
+++ b/commands/property.go
@@ -499,4 +499,3 @@
 
     return nil
 }
-
diff --git a/notes.md b/notes.md
new file mode 100644
index 0000000..0c5cca6
--- /dev/null
+++ b/notes.md
@@ -0,0 +1,736 @@
+
+## Tasks
+- [X] Environment variables
+  + what are they?
+  + unclear ...
+- [x] sdk
+- [x] apibuild + cliversion
+- [x] props variable, revisited
+- [x] Edge ?
+-
+
+---
+
++ parse toml file into properties and constants
++
+
+## Notes
+
+Now testing...  first, read through the tests and make sure that they look like they should pass...
+- [ ] make a list of potentially failing tests -->
+  + [x] activation poll
+    + add method
+      + in python app, `poll` wraps `console`
+        + console
+          + if no `since-`flags have been passed, then return fetch most recent (activation.list({limit:1,}))
+          + else, once a second do:
+            +
+
+    + add flags
+      + sinceSeconds [int ?]
+      + sinceMinutes
+      + sinceHours
+      + sinceDays
+      + exit int
+
+  + [ ] namespace list --> type ?
+  + [ ] add package refresh command / client action
+    + `refresh` command
+      + just takes an optional namespace argument
+    + service
+      +
+  + [x] action create  --> add flags [ and maybe add to client as well ]
+    + [ ] memory
+    + [ ] sequence
+    + [ ] param
+    + [ ] annotation
+    + [ ] timeout
+
+- [ ] fix or approve tests in list
+
+---
+- [x] fails gracelessly when given invalid url as apiHOST
+
+- [x] edge broken
+  - needs protocol / https
+
+
+- [x] set property broken
+
+- [x] (unable to assign apihost with flag)
+
+
+- [x] apibuild does not print out
+--> client.Info.Get()
+    --> info is blank --> print out response body
+
+---
+
+
+
+[x] Props -> namespace --> need to make a request to "/namespaces" first to get a list of legal namespaces, then confirm that requested is legal.
+
+
+---
+
+Need to consider how props is being stored ... --> need to have a single global props, with defaults
+
+
+top-level properties struct
+
+on init, load properties from .wskprops, environment, flags.
+
+initialize client config from properties.
+
+
+
+getProperties --> print out Properties --> according to flags set.
+
+setProperties -->
+
+  readProps
+
+  according to flags, update props
+  write props
+
+
+unsetProperties -->
+
+  readProps
+  delete relevant ones.
+  writeProps
+
+
+readProps -> map[string]string, ok
+writeProps(map[string]string) -> ok
+
+
+---
+
+
+Check that it is up to date...
+Anything known to be missing?
+
+SDK --> simple enough...  just do it.
+
+What's the deal with apibuild, and cliversion ?
+
+Do a side-by-side comparision of wsk versions.  should be the same, except formatting
+
+Anything else I'm missing?
+
+Environment variables.
+WHISK_APIVERSION
+WHISK_AUTH
+WHISK_etc..
+WHISK_
+
+
+
+
+---
+
+Updates to the client / command line api
+
+
+client changes:
+[X] add namespace get / list --> modify to be current (list is list triggers etc for current, get is list of namespaces)
+
+Get namespace contents:
+
+wsk namespace get --> GET /v1/namespaces/_
+wsk namespace get wilsonth@us.ibm.com --> GET /v1/namespaces/_/wilsonth--
+
+Get list of namespaces available
+
+wsk namespace list -> GET /v1/namespaces
+
+So ... --> update namespace client.
+
+
+new top-level flags:
+- `--apihost`: whisk api host
+- `--apiversion`: whisk api version
+
+[X] add `PropertyCmd`
+
+
+Need to remove persistent global flags and re-add. (auth etc.)
+
+- use: "work with whisk properties"
+- set
+  + -u, --auth
+  + --apihost
+  + --apiversion
+  + --namespace
+
+
+- get
+  + -u, --auth
+  + --apihost
+  + --apiversion
+  + --cliversion
+  + --apibuild
+  + --namespace
+  + --all
+
+Namespace --> api is `:443/api/{apivesion}/namespaces/{namespace}`
+
+[x] remove top-level commands:
+- auth
+- list
+- whoami
+- health
+- clean
+- namespace
+- version
+
+remove top-level flags:
+
+- --auth (added to local level ?)
+-
+
+
+
+Implemenmt sdk command
+- install
+  - component {docker, swift, iOS}
+
+---
+
+Parsing params, annotations, and action#invoke payload --> as json data
+
+params and annotations --> attempt to parse as json into map[string]interface{}.  if it fails, then throw error
+
+payload is the same except for that if it is not valid json then obj is created "{payload: arg}".
+
+What about response object ??  Will also be a map[string]interface{} ?? 
+
+To start: --> change action invoke :payload to a map[string]interface{} and see if it breaks.
+
+Ok mostly working ...
+
+--> need to add it back in to
+- [x] trigger
+- [x] package
+- [x] rule ?
+
+
+What does trigger#fire return?  {id: "id"}
+
+
+
+---
+Order of variables: flags -> env -> .wsk
+
+1. load flags, env, and .wsk (props)
+2. for each value, check and assign in order
+3. initialize client + other variables that depend on values
+
+config:
+- `auth`
+- `namespace`
+- `edge`
+
+- [X] load props and env. variables in main init.  Write a top-level persistent pre-run function to read the command line variables.
+
+- [X] add setter functions
+  + [X] `auth`
+  + [X] `namespace`
+
+---
+
+package.bind ...
+
+```python
+
+def bind(self, args, props):
+        url = 'https://%(url)s/api/v1/%(namespace)s/packages/%(name)s' % {
+            'url': props['api'],
+            'namespace': urllib.quote(args.namespace),
+            'name': self.getSafeName(args.name)
+        }
+        split = args.package.split(':')
+        binding = {}
+        if (len(split) == 1):
+            binding = { 'name': split[0], 'namespace': args.namespace}
+        elif (len(split) == 2):
+            binding = { 'name': split[1], 'namespace': split[0]}
+        else:
+            print 'package name malformed. name or namespace/name allowed'
+            sys.exit(1)
+
+        payload = {
+            'name': args.name,
+            'binding': binding,
+            'annotations': getAnnotations(args),
+            'parameters': getParams(args)
+        }
+        args.shared = False
+        self.addPublish(payload, args)
+        headers= {
+            'Content-Type': 'application/json'
+        }
+        res = request('PUT', url, json.dumps(payload), headers, auth=args.auth, verbose=args.verbose)
+
+        resBody = res.read()
+        result = json.loads(resBody)
+
+        if res.status == httplib.OK:
+            print 'ok: created binding %(name)s ' % {'name': args.name }
+            return 0
+        else:
+            print 'error: ' + result['error']
+            return res.status
+```
+
+---
+
+
+```python
+
+def create(self, args, props, update):
+        exe = self.getExec(args, props)
+        if args.pipe:
+            if args.param is None:
+                args.param = []
+            args.param.append([ '_actions', json.dumps(self.csvToList(args.artifact))])
+
+        validExe = exe is not None and ('image' in exe or 'code' in exe)
+        if update or validExe: # if create action, then exe must be valid
+            payload = {
+               'name': args.name,
+               'annotations': getAnnotations(args),
+               'parameters': getParams(args),
+               'limits' : self.getLimits(args)
+            }
+            if validExe:
+                payload['exec'] = exe
+            self.addPublish(payload, args)
+            return self.put(args, props, update, json.dumps(payload))
+        else:
+            print 'the artifact "%s" is not a valid file. If this is a docker image, use --docker.' % args.artifact
+            return 2
+
+
+# creates { code: "js code", image: "docker image", initializer: "base64 encoded string" }
+# where code and image are mutually exclusive and initializer is optional
+def getExec(self, args, props):
+    exe = {}
+    if args.docker:
+        exe['image'] = args.artifact
+    elif args.copy:
+        existingAction = args.artifact
+        exe = self.getActionExec(args, props, existingAction)
+    elif args.pipe:
+        args2 = copy.copy(args) # shallow copy of args object
+        args2.namespace = 'client.system'
+        pipeAction = 'common/pipe'
+        exe = self.getActionExec(args2, props, pipeAction)
+    elif args.artifact is not None and os.path.isfile(args.artifact):
+        exe['code'] = open(args.artifact, 'rb').read()
+    if args.lib:
+        exe['initializer'] = base64.b64encode(args.lib.read())
+    return exe
+
+def getActionExec(self, args, props, name):
+    res = self.Get(args, props, name)
+    resBody = res.read()
+    if res.status == httplib.OK:
+        execField = json.loads(resBody)['exec']
+    else:
+        execField = None
+    return execField
+
+```
+
+
+Action Create:
+
+```golang
+
+  if flags.docker
+    exec.image = artifact // what artifact ?
+
+  else if flags.copy
+    -> actions.Get(actionName), copy exec
+
+  else if flags.pipe
+    -> (copy args)
+    -> client.Config.Namespace = "client.system"
+    -> actionName = "common/pipe"
+    -> actions.Get(actionName), copy exec
+
+  else if artifact != "" && os.FileExists(artifact)
+    -> exec.code = os.ReadFile(artifact)
+
+  if flags.lib
+    -> exec.init = base64.Encode(flag.lib.read())  // lib is gzipped or tar file.
+
+
+
+
+```
+
+
+---
+
+Thinking about how to persist data in between wsk calls.  The way that the python version does it is to write to a file on disk.  What other ways are there to do this?
+- How does github cli do this ?
+
+- Start working on command ...
+  + fill out methods.
+    + first need to create a reference to the whisk...  Top-level variable. --> parse flags, then assign
+
+## To do's
+
+- [X] actionInvokeCmd --> parse payload properly.
+
+- [ ] better error responses
+  + read resp.Body for message.
+
+- [ ] Add support for environment variables
+  - EDGE_HOST
+  - CLI_API_HOST
+  - WHISK_VERSION_DATE
+
+- [x] create action
+  + see above
+- [ ] verbose
+- [ ] Verbose (with a writer or something fancy)
+  + how to avoid putting this on the client ?
+- [X] params / annotations
+- [X] positional arguments
+- [ ] SDK
+
+
+- [X] finish all simple methods
+  + [x] package
+  + [X] rule
+  + [X] trigger
+
+- [ ] Figure out how to properly define positional arguments with cobra / pflags.
+
+- [ ] Implement verbose mode to help with debugging.
+
+- [X] finish complex methods
+  + [X] Action.Create with exec and all flags
+  + [X] Action.Invoke with params
+
+- Local install
+  - vagrant.
+  - test everything locally, include how in docs.
+  - Debug locally.
+
+- review how other cli packages store props (to disk)
+  + hugo
+  + github
+
+- Cmd
+  + implement loadConfig + updateConfig
+  + add basic Client methods
+    + auth
+    + clean
+    + version
+  + add verbose
+  + add arguments
+  + add flags
+    + top-level
+    + sub-cmd-level
+
+  + add messages
+  + add functions (link up with stubbed out client + props)
+- Client
+  + [X] stub out methods for all services (with arguments)
+  + [X] complete services
+  + [X] complete request method for Client ()
+  + [X] figure out what namespaces is about
+  + [X] add auth to Client
+
+
+
+## Solutions
+
+
+
+
+<!--
+
+NONE OF THIS MATTERS!  stuff is reloaded every time the
+ - watching props
+  + have a loadPropsFromFile function
+    + if file missing, use default
+  + have an update prop(s) function
+    + updates the file.
+  + have a watch propsFile function -> updates client when it detects a change. -->
+
+- auth
+  + include token in Client struct (base64 encoded?)
+  + Add Auth header in *whisk.Request
+- verbose
+  + include bool in Client struct
+  + print out in *whisk.Do
+- BUT ALSO!!!
+  + need to store on disk so that it is the same in between invocations.  This is done in cmd --> initialized the client based on contents of .wskprops
+
+## Code Samples From whisk *python
+
+---
+
+`wskitem.py`
+
+```python
+def put(self, args, props, update, payload):
+  url = 'https://%(url)s/%(service)s/v1/%(namespace)s/%(collection)s/%(name)s%(update)s' % {
+      'url': props[self.service],
+      'service': self.service,
+      'namespace': urllib.quote(args.namespace),
+      'collection': self.collection,
+      'name': self.getSafeName(args.name),
+      'update': '?overwrite=true' if update else ''
+  }
+
+  headers= {
+      'Content-Type': 'application/json'
+  }
+
+  res = request('PUT', url, payload, headers, auth=args.auth, verbose=args.verbose)
+  resBody = res.read()
+
+  if res.status == httplib.OK:
+      print 'ok: %(mode)s %(item)s %(name)s' % { 'mode': 'updated' if update else 'created', 'item': self.name, 'name': args.name }
+      return 0
+  else:
+      result = json.loads(resBody)
+      print 'error: ' + result['error']
+      return res.status
+```
+
+- This gives the url structure for resource requests
+- `request` is defined in `wskutil.py`
+
+---
+
+`wskutil.py`
+
+```python
+def request(method, urlString, body = "", headers = {}, auth = None, verbose = False):
+    url = urlparse(urlString)
+    if url.scheme == 'http':
+        conn = httplib.HTTPConnection(url.netloc)
+    else:
+        if hasattr(ssl, '_create_unverified_context'):
+            conn = httplib.HTTPSConnection(url.netloc, context=ssl._create_unverified_context())
+        else:
+            conn = httplib.HTTPSConnection(url.netloc)
+
+    if auth != None:
+        auth = base64.encodestring(auth).replace('\n', '')
+        headers['Authorization'] = 'Basic %s' % auth
+
+    if verbose:
+        print "========"
+        print "REQUEST:"
+        print "%s %s" % (method, urlString)
+        print "Headers sent:"
+        print json.dumps(headers, indent=4)
+        if body != "":
+            print "Body sent:"
+            print body
+
+    conn.request(method, urlString, body, headers)
+    res = conn.getresponse()
+    body = res.read()
+
+    # patch the read to return just the body since the normal read
+    # can only be done once
+    res.read = lambda: body
+
+    if verbose:
+        print "--------"
+        print "RESPONSE:"
+        print "Got response with code %s" % res.status
+        print "Body received:"
+        print res.read()
+        print "========"
+
+    return res
+```
+
+- Shows auth scheme --> just base64 encode and use basic authorization for requests
+
+
+## Code samples from hugo
+
+---
+
+from `commands/hugo.go`
+
+```go
+
+// Execute adds all child commands to the root command HugoCmd and sets flags appropriately.
+func Execute() {
+	HugoCmd.SetGlobalNormalizationFunc(helpers.NormalizeHugoFlags)
+
+	HugoCmd.SilenceUsage = true
+
+	AddCommands()
+
+	if c, err := HugoCmd.ExecuteC(); err != nil {
+		if isUserError(err) {
+			c.Println("")
+			c.Println(c.UsageString())
+		}
+
+		return
+	}
+}
+
+// AddCommands adds child commands to the root command HugoCmd.
+func AddCommands() {
+	HugoCmd.AddCommand(serverCmd)
+	HugoCmd.AddCommand(versionCmd)
+	HugoCmd.AddCommand(configCmd)
+	HugoCmd.AddCommand(checkCmd)
+	HugoCmd.AddCommand(benchmarkCmd)
+	HugoCmd.AddCommand(convertCmd)
+	HugoCmd.AddCommand(newCmd)
+	HugoCmd.AddCommand(listCmd)
+	HugoCmd.AddCommand(undraftCmd)
+	HugoCmd.AddCommand(importCmd)
+
+	HugoCmd.AddCommand(genCmd)
+	genCmd.AddCommand(genautocompleteCmd)
+	genCmd.AddCommand(gendocCmd)
+	genCmd.AddCommand(genmanCmd)
+}
+
+```
+
+- use a top-level execute function like this to wrap Cmd.Execute().
+- Add all the commands in one place in the main function --> makes it much easier to see what's going on vs. in lots of different init files --> also easier to update / edit etc.
+
+```go
+
+
+
+
+// Flags that are to be added to commands.
+var BuildWatch, IgnoreCache, Draft, Future, UglyURLs, CanonifyURLs, Verbose, Logging, VerboseLog, DisableRSS, DisableSitemap, DisableRobotsTXT, PluralizeListTitles, PreserveTaxonomyNames, NoTimes, ForceSync bool
+var Source, CacheDir, Destination, Theme, BaseURL, CfgFile, LogFile, Editor string
+
+func initCoreCommonFlags(cmd *cobra.Command) {
+	cmd.Flags().BoolVarP(&Draft, "buildDrafts", "D", false, "include content marked as draft")
+	cmd.Flags().BoolVarP(&Future, "buildFuture", "F", false, "include content with publishdate in the future")
+	cmd.Flags().BoolVar(&DisableRSS, "disableRSS", false, "Do not build RSS files")
+	cmd.Flags().BoolVar(&DisableSitemap, "disableSitemap", false, "Do not build Sitemap file")
+	cmd.Flags().BoolVar(&DisableRobotsTXT, "disableRobotsTXT", false, "Do not build Robots TXT file")
+	cmd.Flags().StringVarP(&Source, "source", "s", "", "filesystem path to read files relative from")
+	cmd.Flags().StringVarP(&CacheDir, "cacheDir", "", "", "filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/")
+	cmd.Flags().BoolVarP(&IgnoreCache, "ignoreCache", "", false, "Ignores the cache directory for reading but still writes to it")
+	cmd.Flags().StringVarP(&Destination, "destination", "d", "", "filesystem path to write files to")
+	cmd.Flags().StringVarP(&Theme, "theme", "t", "", "theme to use (located in /themes/THEMENAME/)")
+	cmd.Flags().BoolVar(&UglyURLs, "uglyURLs", false, "if true, use /filename.html instead of /filename/")
+	cmd.Flags().BoolVar(&CanonifyURLs, "canonifyURLs", false, "if true, all relative URLs will be canonicalized using baseURL")
+	cmd.Flags().StringVarP(&BaseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. http://spf13.com/")
+	cmd.Flags().StringVar(&CfgFile, "config", "", "config file (default is path/config.yaml|json|toml)")
+	cmd.Flags().StringVar(&Editor, "editor", "", "edit new content with this editor, if provided")
+	cmd.Flags().BoolVar(&nitro.AnalysisOn, "stepAnalysis", false, "display memory and timing of different steps of the program")
+	cmd.Flags().BoolVar(&PluralizeListTitles, "pluralizeListTitles", true, "Pluralize titles in lists using inflect")
+	cmd.Flags().BoolVar(&PreserveTaxonomyNames, "preserveTaxonomyNames", false, `Preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")`)
+	cmd.Flags().BoolVarP(&ForceSync, "forceSyncStatic", "", false, "Copy all files when static is changed.")
+	// For bash-completion
+	validConfigFilenames := []string{"json", "js", "yaml", "yml", "toml", "tml"}
+	cmd.Flags().SetAnnotation("config", cobra.BashCompFilenameExt, validConfigFilenames)
+	cmd.Flags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+	cmd.Flags().SetAnnotation("cacheDir", cobra.BashCompSubdirsInDir, []string{})
+	cmd.Flags().SetAnnotation("destination", cobra.BashCompSubdirsInDir, []string{})
+	cmd.Flags().SetAnnotation("theme", cobra.BashCompSubdirsInDir, []string{"themes"})
+}
+```
+
+- Parse variables like this.
+
+---
+
+
+## Thoughts
+
+---
+
+Now... -> fill out command functions.
+
+Perhaps start with a different function... with fewer flags ??
+
+
+Need to figure out how flags will be done...
+
+Can put in cmd.init() functions ??  yeah ...
+
+would be really nice if i could test this ...
+
+
+---
+
+How to set namespace properly... ?
+
+stored in .wskprops, initialized in whisk.
+client offers namespaceService.List() only.
+
+---
+
+Review other python cli commands that are not listed in swagger doc (e.g. namespaces, sdk )
+
+---
+What does "clean" do ??
+
+---
+
+What am I doing with Config / props ??
+
+What is the requirement?
+> read .wsk config into map[string]string
+> write map[string]string to file (configurable)
+
+
+---
+
+
+current issue:
+Optional parameters... should not be listed in url params.  If not there, then don't print.
+e.g. How to deal with activationsListOptions .since and .upto
+
+possible solution: use pointers.  if pointer is nil, then ignore.
+
+
+```go
+func addRouteOptions(route string, options interface{}) (string, error) {
+	v := reflect.ValueOf(options)
+	if v.Kind() == reflect.Ptr && v.IsNil() {
+		return route, nil
+	}
+
+	u, err := url.Parse(route)
+	if err != nil {
+		return route, err
+	}
+
+	qs, err := query.Values(options)
+	if err != nil {
+		return route, err
+	}
+
+	u.RawQuery = qs.Encode()
+	return u.String(), nil
+}
+```
+- How does go-querystring/query.Values() work ?? has options ??
+  + want to take all non-nil values from options and write key=value in url.  Should ignore nil values (like for pointers and empty structs.)
+
+
+Already does this!  using the tags... --> omit empty.  Anything to worry about then ... ?
+
+
+- consider using pointers to structs.
+-
+- for now, just flag and skip anything difficult.
diff --git a/tools/travis/install_openwhisk.sh b/tools/travis/install_openwhisk.sh
index 56d3799..ae0d5ed 100755
--- a/tools/travis/install_openwhisk.sh
+++ b/tools/travis/install_openwhisk.sh
@@ -16,7 +16,7 @@
 docker info
 
 # Ansible
-pip install --user ansible==2.1.2.0
+pip install --user ansible==2.3.0.0
 
 # Clone the OpenWhisk code
 git clone --depth 3 https://github.com/openwhisk/openwhisk.git