fix(graph): fix for table legend and scroll, fixes #7204 , fixes #6628

updates packagecloud script
tech(build): updates circle ci trigger scripts
2017-01-11 10:38:10 +01:00 · 2017-01-10 15:09:01 +01:00 · 2017-01-10 15:06:48 +01:00 · 2017-01-10 14:59:06 +01:00 · 2017-01-10 13:33:04 +01:00 · 2017-01-10 10:34:51 +01:00
3160 changed files with 361212 additions and 125091 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -2,7 +2,7 @@
 root = true

 [*.go]
-indent_style = tabs
+indent_style = tab
 indent_size = 2
 charset = utf-8
 trim_trailing_whitespace = true
--- a/.floo
+++ b/.floo
@@ -0,0 +1,3 @@
+{
+  "url": "https://floobits.com/raintank/grafana"
+}
--- a/.flooignore
+++ b/.flooignore
@@ -0,0 +1,12 @@
+#*
+*.o
+*.pyc
+*.pyo
+*~
+extern/
+node_modules/
+tmp/
+data/
+vendor/
+public_gen/
+dist/
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -12,11 +12,11 @@ grunt karma:dev

 ### Run tests for backend assets before commit
 ```
-test -z "$(gofmt -s -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)"
+test -z "$(gofmt -s -l . | grep -v -E 'vendor/(github.com|golang.org|gopkg.in)' | tee /dev/stderr)"
 ```

 ### Run tests for frontend assets before commit
 ```
-grunt test
-godep go test -v ./pkg/...
+npm test
+go test -v ./pkg/...
 ```
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,12 +1,18 @@
-Thank you! For helping us make Grafana even better.
+Please prefix your title with [Bug] or [Feature request]
+For question please check [Support Options](http://grafana.org/support/). **Do not** open a github issue

-To help us respond to your issues faster, please make sure to add as much information as possible.
+Please include this information:
+- What Grafana version are you using?
+- What datasource are you using?
+- What OS are you running grafana on?
+- What did you do?
+- What was the expected result?
+- What happened instead?

-If this issue is about a plugin, please open the issue in that repository.
+**IMPORTANT** 
+If it relates to *metric data viz*:
+- An image or text representation of your metric query
+- The raw query and response for the network request (check this in chrome dev tools network tab, here you can see metric requests and other request, please include the request body and request response)

-Start your issues title with [Feature Request] / [Bug] / [Question] or no tag if your unsure.
-
-Ex
-* What grafana version are you using?
-* What datasource are you using?
-* What OS are you running grafana on?
+If it relates to *alerting*
+- An image of the test execution data fully expanded.
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,2 +1,4 @@
 * Link the PR to an issue for new features
-* Rebase your PR if it gets out of sync with master
+* Rebase your PR if it gets out of sync with master
+
+**REMOVE THE TEXT ABOVE BEFORE CREATING THE PULL REQUEST**
--- a/.gitignore
+++ b/.gitignore
@@ -25,6 +25,7 @@ public/css/*.min.css
 *.swp
 .idea/
 *.iml
+.vscode/

 /data/*
 /bin/*
@@ -37,4 +38,4 @@ profile.cov
 .notouch
 /pkg/cmd/grafana-cli/grafana-cli
 /pkg/cmd/grafana-server/grafana-server
-/examples/*/dist
+/examples/*/dist
--- a/.hooks/pre-commit
+++ b/.hooks/pre-commit
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash

-test -z "$(gofmt -s -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)"
+test -z "$(gofmt -s -l . | grep -v vendor/src/ | tee /dev/stderr)"
 if [ $? -gt 0 ]; then
    echo "Some files aren't formatted, please run 'go fmt ./pkg/...' to format your source code before committing"
    exit 1
--- a/.jscs.json
+++ b/.jscs.json
@@ -10,4 +10,4 @@
    "disallowSpacesInsideArrayBrackets": true,
    "disallowSpacesInsideParentheses": true,
    "validateIndentation": 2
-}
+}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,267 @@
-# 3.0.0-beta4 (unreleased)
+# 4.2.0 (unreleased)
+
+# 4.0.0 (unreleased)
+
+### Bugfixes
+* **Server side PNG rendering**: Fixed issue with y-axis label rotation in phantomjs rendered images [#6924](https://github.com/grafana/grafana/issues/6924)
+* **Graph**: Fixed centering of y-axis label [#7099](https://github.com/grafana/grafana/issues/7099)
+* **Graph**: Fixed graph legend table mode and always visible scrollbar [#6828](https://github.com/grafana/grafana/issues/6828)
+* **Templating**: Fixed template variable value groups/tags feature [#6752](https://github.com/grafana/grafana/issues/6752)
+
+## Enhancements
+* **Elasticsearch**: Added support for all moving average options [#7154](https://github.com/grafana/grafana/pull/7154), thx [@vaibhavinbayarea](https://github.com/vaibhavinbayarea)
+
+# 4.1-beta1 (2016-12-21)
+
+### Enhancements
+* **Postgres**: Add support for Certs for Postgres database [#6655](https://github.com/grafana/grafana/issues/6655)
+* **Victorops**: Add VictorOps notification integration [#6411](https://github.com/grafana/grafana/issues/6411), thx [@ichekrygin](https://github.com/ichekrygin)
+* **Opsgenie**: Add OpsGenie notification integratiion [#6687](https://github.com/grafana/grafana/issues/6687), thx [@kylemcc](https://github.com/kylemcc)
+* **Singlestat**: New aggregation on singlestat panel [#6740](https://github.com/grafana/grafana/pull/6740), thx [@dirk-leroux](https://github.com/dirk-leroux)
+* **Cloudwatch**: Make it possible to specify access and secret key on the data source config page [#6697](https://github.com/grafana/grafana/issues/6697)
+* **Table**: Added Hidden Column Style for Table Panel [#5677](https://github.com/grafana/grafana/pull/5677), thx [@bmundt](https://github.com/bmundt)
+* **Graph**: Shared crosshair option renamed to shared tooltip, shows tooltip on all graphs as you hover over one graph. [#1578](https://github.com/grafana/grafana/pull/1578), [#6274](https://github.com/grafana/grafana/pull/6274)
+* **Elasticsearch**: Added support for Missing option (bucket) for terms aggregation [#4244](https://github.com/grafana/grafana/pull/4244), thx [@shanielh](https://github.com/shanielh)
+* **Elasticsearch**: Added support for Elasticsearch 5.x [#5740](https://github.com/grafana/grafana/issues/5740), thx [@lpic10](https://github.com/lpic10)
+* **CLI**: Make it possible to reset the admin password using the grafana-cli. [#5479](https://github.com/grafana/grafana/issues/5479)
+* **Influxdb**: Support multiple tags in InfluxDB annotations. [#4550](https://github.com/grafana/grafana/pull/4550), thx [@adrianlzt](https://github.com/adrianlzt)
+* **LDAP**:  Basic Auth now supports LDAP username and password, [#6940](https://github.com/grafana/grafana/pull/6940), thx [@utkarshcmu](https://github.com/utkarshcmu)
+* **LDAP**: Now works with Auth Proxy, role and organisation mapping & sync will regularly be performed. [#6895](https://github.com/grafana/grafana/pull/6895), thx [@Seuf](https://github.com/seuf)
+* **Alerting**: Adds OK as no data option. [#6866](https://github.com/grafana/grafana/issues/6866)
+* **Alert list**: Order alerts based on state. [#6676](https://github.com/grafana/grafana/issues/6676)
+* **Alerting**: Add api endpoint for pausing all alerts. [#6589](https://github.com/grafana/grafana/issues/6589)
+* **Panel**: Added help text for panels. [#4079](https://github.com/grafana/grafana/issues/4079), thx [@utkarshcmu](https://github.com/utkarshcmu)
+
+### Bugfixes
+* **API**: HTTP API for deleting org returning incorrect message for a non-existing org [#6679](https://github.com/grafana/grafana/issues/6679)
+* **Dashboard**: Posting empty dashboard result in corrupted dashboard [#5443](https://github.com/grafana/grafana/issues/5443)
+* **Logging**: Fixed logging level confing issue [#6978](https://github.com/grafana/grafana/issues/6978)
+* **Notifications**: Remove html escaping the email subject. [#6905](https://github.com/grafana/grafana/issues/6905)
+* **Influxdb**: Fixes broken field dropdown when using template vars as measurement. [#6473](https://github.com/grafana/grafana/issues/6473)
+
+# 4.0.3 (unreleased)
+
+### Bugfixes
+* **Influxdb**: Handles time(auto) the same way as time($interval) [#6997](https://github.com/grafana/grafana/issues/6997)
+
+# 4.0.2 (2016-12-08)
+
+### Enhancements
+* **Playlist**: Add support for kiosk mode [#6727](https://github.com/grafana/grafana/issues/6727)
+
+### Bugfixes
+* **Alerting**: Add alert message to webhook notifications [#6807](https://github.com/grafana/grafana/issues/6807)
+* **Alerting**: Fixes a bug where avg() reducer treated null as zero. [#6879](https://github.com/grafana/grafana/issues/6879)
+* **PNG Rendering**: Fix for server side rendering when using non default http addr bind and domain setting [#6813](https://github.com/grafana/grafana/issues/6813)
+* **PNG Rendering**: Fix for server side rendering when setting enforce_domain to true [#6769](https://github.com/grafana/grafana/issues/6769)
+* **Webhooks**: Add content type json to outgoing webhooks [#6822](https://github.com/grafana/grafana/issues/6822)
+* **Keyboard shortcut**: Fixed zoom out shortcut [#6837](https://github.com/grafana/grafana/issues/6837)
+* **Webdav**: Adds basic auth headers to webdav uploader [#6779](https://github.com/grafana/grafana/issues/6779)
+
+# 4.0.1 (2016-12-02)
+
+> **Notice**
+4.0.0 had serious connection pooling issue when using a data source in proxy access. This bug caused lots of resource issues
+due to too many connections/file handles on the data source backend. This problem is fixed in this release.
+
+### Bugfixes
+* **Metrics**: Fixes nil pointer dereference on my arm build [#6749](https://github.com/grafana/grafana/issues/6749)
+* **Data proxy**: Fixes a tcp pooling issue in the datasource reverse proxy [#6759](https://github.com/grafana/grafana/issues/6759)
+
+# 4.0-stable (2016-11-29)
+
+### Bugfixes
+* **Server-side rendering**: Fixed address used when rendering panel via phantomjs and using non default http_addr config [#6660](https://github.com/grafana/grafana/issues/6660)
+* **Graph panel**: Fixed graph panel tooltip sort order issue [#6648](https://github.com/grafana/grafana/issues/6648)
+* **Unsaved changes**: You now navigate to the intended page after saving in the unsaved changes dialog [#6675](https://github.com/grafana/grafana/issues/6675)
+* **TLS Client Auth**: Support for TLS client authentication for datasource proxies [#2316](https://github.com/grafana/grafana/issues/2316)
+* **Alerts out of sync**: Saving dashboards with broken alerts causes sync problem[#6576](https://github.com/grafana/grafana/issues/6576)
+* **Alerting**: Saving an alert with condition "HAS NO DATA" throws an error[#6701](https://github.com/grafana/grafana/issues/6701)
+* **Config**: Improve error message when parsing broken config file [#6731](https://github.com/grafana/grafana/issues/6731)
+* **Table**: Render empty dates as - instead of current date [#6728](https://github.com/grafana/grafana/issues/6728)
+
+# 4.0-beta2 (2016-11-21)
+
+### Bugfixes
+* **Graph Panel**: Log base scale on right Y-axis had no effect, max value calc was not applied, [#6534](https://github.com/grafana/grafana/issues/6534)
+* **Graph Panel**: Bar width if bars was only used in series override, [#6528](https://github.com/grafana/grafana/issues/6528)
+* **UI/Browser**: Fixed issue with page/view header gradient border not showing in Safari, [#6530](https://github.com/grafana/grafana/issues/6530)
+* **Cloudwatch**: Fixed cloudwatch datasource requesting to many datapoints, [#6544](https://github.com/grafana/grafana/issues/6544)
+* **UX**: Panel Drop zone visible after duplicating panel, and when entering fullscreen/edit view, [#6598](https://github.com/grafana/grafana/issues/6598)
+* **Templating**: Newly added variable was not visible directly only after dashboard reload, [#6622](https://github.com/grafana/grafana/issues/6622)
+
+### Enhancements
+* **Singlestat**: Support repeated template variables in prefix/postfix [#6595](https://github.com/grafana/grafana/issues/6595)
+* **Templating**: Don't persist variable options with refresh option [#6586](https://github.com/grafana/grafana/issues/6586)
+* **Alerting**: Add ability to have OR conditions (and mixing AND & OR) [#6579](https://github.com/grafana/grafana/issues/6579)
+* **InfluxDB**: Fix for Ad-Hoc Filters variable & changing dashboards [#6821](https://github.com/grafana/grafana/issues/6821)
+
+# 4.0-beta1 (2016-11-09)
+
+### Enhancements
+* **Login**: Adds option to disable username/password logins, closes [#4674](https://github.com/grafana/grafana/issues/4674)
+* **SingleStat**: Add seriename as option in singlestat panel, closes [#4740](https://github.com/grafana/grafana/issues/4740)
+* **Localization**: Week start day now dependant on browser locale setting, closes [#3003](https://github.com/grafana/grafana/issues/3003)
+* **Templating**: Update panel repeats for variables that change on time refresh, closes [#5021](https://github.com/grafana/grafana/issues/5021)
+* **Templating**: Add support for numeric and alphabetical sorting of variable values, closes [#2839](https://github.com/grafana/grafana/issues/2839)
+* **Elasticsearch**: Support to set Precision Threshold for Unique Count metric, closes [#4689](https://github.com/grafana/grafana/issues/4689)
+* **Navigation**: Add search to org swithcer, closes [#2609](https://github.com/grafana/grafana/issues/2609)
+* **Database**: Allow database config using one propertie, closes [#5456](https://github.com/grafana/grafana/pull/5456)
+* **Graphite**: Add support for groupByNodes, closes [#5613](https://github.com/grafana/grafana/pull/5613)
+* **Influxdb**: Add support for elapsed(), closes [#5827](https://github.com/grafana/grafana/pull/5827)
+* **OpenTSDB**: Add support for explicitTags for OpenTSDB>=2.3, closes [#6360](https://github.com/grafana/grafana/pull/6361)
+* **OAuth**: Add support for generic oauth, closes [#4718](https://github.com/grafana/grafana/pull/4718)
+* **Cloudwatch**: Add support to expand multi select template variable, closes [#5003](https://github.com/grafana/grafana/pull/5003)
+* **Background Tasks**: Now support automatic purging of old snapshots, closes [#4087](https://github.com/grafana/grafana/issues/4087)
+* **Background Tasks**: Now support automatic purging of old rendered images, closes [#2172](https://github.com/grafana/grafana/issues/2172)
+* **Dashboard**: After inactivity hide nav/row actions, fade to nice clean view, can be toggled with `d v`, also added kiosk mode, toggled via `d k` [#6476](https://github.com/grafana/grafana/issues/6476)
+* **Dashboard**: Improved dashboard row menu & add panel UX [#6442](https://github.com/grafana/grafana/issues/6442)
+* **Graph Panel**: Support for stacking null values [#2912](https://github.com/grafana/grafana/issues/2912), [#6287](https://github.com/grafana/grafana/issues/6287), thanks @benrubson!
+
+### Breaking changes
+* **SystemD**: Change systemd description, closes [#5971](https://github.com/grafana/grafana/pull/5971)
+* **lodash upgrade**: Upgraded lodash from 2.4.2 to 4.15.0, this contains a number of breaking changes that could effect plugins. closes [#6021](https://github.com/grafana/grafana/pull/6021)
+
+### Bug fixes
+* **Table Panel**: Fixed problem when switching to Mixed datasource in metrics tab, fixes [#5999](https://github.com/grafana/grafana/pull/5999)
+* **Playlist**: Fixed problem with play order not matching order defined in playlist, fixes [#5467](https://github.com/grafana/grafana/pull/5467)
+* **Graph panel**: Fixed problem with auto decimals on y axis when datamin=datamax, fixes [#6070](https://github.com/grafana/grafana/pull/6070)
+* **Snapshot**: Can view embedded panels/png rendered panels in snapshots without login, fixes [#3769](https://github.com/grafana/grafana/pull/3769)
+* **Elasticsearch**: Fix for query template variable when looking up terms without query, no longer relies on elasticsearch default field, fixes [#3887](https://github.com/grafana/grafana/pull/3887)
+* **Elasticsearch**: Fix for displaying IP address used in terms aggregations, fixes [#4393](https://github.com/grafana/grafana/pull/4393)
+* **PNG Rendering**: Fix for server side rendering when using auth proxy, fixes [#5906](https://github.com/grafana/grafana/pull/5906)
+* **OpenTSDB**: Fixed multi-value nested templating for opentsdb, fixes [#6455](https://github.com/grafana/grafana/pull/6455)
+* **Playlist**: Remove playlist items when dashboard is removed, fixes [#6292](https://github.com/grafana/grafana/issues/6292)
+
+# 3.1.2 (unreleased)
+* **Templating**: Fixed issue when combining row & panel repeats, fixes [#5790](https://github.com/grafana/grafana/issues/5790)
+* **Drag&Drop**: Fixed issue with drag and drop in latest Chrome(51+), fixes [#5767](https://github.com/grafana/grafana/issues/5767)
+* **Internal Metrics**: Fixed issue with dots in instance_name when sending internal metrics to Graphite, fixes [#5739](https://github.com/grafana/grafana/issues/5739)
+* **Grafana-CLI**: Add default plugin path for MAC OS, fixes [#5806](https://github.com/grafana/grafana/issues/5806)
+* **Grafana-CLI**: Improve error message for upgrade-all command, fixes [#5885](https://github.com/grafana/grafana/issues/5885)
+
+# 3.1.1 (2016-08-01)
+* **IFrame embedding**: Fixed issue of using full iframe height, fixes [#5605](https://github.com/grafana/grafana/issues/5606)
+* **Panel PNG rendering**: Fixed issue detecting render completion, fixes [#5605](https://github.com/grafana/grafana/issues/5606)
+* **Elasticsearch**: Fixed issue with templating query and json parse error, fixes [#5615](https://github.com/grafana/grafana/issues/5615)
+* **Tech**: Upgraded JQuery to 2.2.4 to fix Security vulnerabilitie in 2.1.4, fixes [#5627](https://github.com/grafana/grafana/issues/5627)
+* **Graphite**: Fixed issue with mixed data sources and Graphite, fixes [#5617](https://github.com/grafana/grafana/issues/5617)
+* **Templating**: Fixed issue with template variable query was issued multiple times during dashboard load, fixes [#5637](https://github.com/grafana/grafana/issues/5637)
+* **Zoom**: Fixed issues with zoom in and out on embedded (iframed) panel, fixes [#4489](https://github.com/grafana/grafana/issues/4489), [#5666](https://github.com/grafana/grafana/issues/5666)
+
+# 3.1.0 stable (2016-07-12)
+
+### Bugfixes & Enhancements,
+* **User Alert Notices**: Backend error alert popups did not show properly, fixes [#5435](https://github.com/grafana/grafana/issues/5435)
+* **Table**: Added sanitize HTML option to allow links in table cells, fixes [#4596](https://github.com/grafana/grafana/issues/4596)
+* **Apps**: App dashboards are automatically synced to DB at startup after plugin update, fixes [#5529](https://github.com/grafana/grafana/issues/5529)
+
+# 3.1.0-beta1 (2016-06-23)
+
+### Enhancements
+* **Dashboard Export/Import**: Dashboard export now templetize data sources and constant variables, users pick these on import, closes [#5084](https://github.com/grafana/grafana/issues/5084)
+* **Dashboard Url**: Time range changes updates url, closes [#458](https://github.com/grafana/grafana/issues/458)
+* **Dashboard Url**: Template variable change updates url, closes [#5002](https://github.com/grafana/grafana/issues/5002)
+* **Singlestat**: Add support for range to text mappings, closes [#1319](https://github.com/grafana/grafana/issues/1319)
+* **Graph**: Adds sort order options for graph tooltip, closes  [#1189](https://github.com/grafana/grafana/issues/1189)
+* **Theme**: Add default theme to config file [#5011](https://github.com/grafana/grafana/pull/5011)
+* **Page Footer**: Added page footer with links to docs, shows Grafana version and info if new version is available, closes [#4889](https://github.com/grafana/grafana/pull/4889)
+* **InfluxDB**: Add spread function, closes [#5211](https://github.com/grafana/grafana/issues/5211)
+* **Scripts**: Use restart instead of start for deb package script, closes [#5282](https://github.com/grafana/grafana/pull/5282)
+* **Logging**: Moved to structured logging lib, and moved to component specific level filters via config file, closes [#4590](https://github.com/grafana/grafana/issues/4590)
+* **OpenTSDB**: Support nested template variables in tag_values function, closes [#4398](https://github.com/grafana/grafana/issues/4398)
+* **Datasource**: Pending data source requests are cancelled before new ones are issues (Graphite & Prometheus), closes [#5321](https://github.com/grafana/grafana/issues/5321)
+
+### Breaking changes
+* **Logging** : Changed default logging output format (now structured into message, and key value pairs, with logger key acting as component). You can also no change in config to json log ouput.
+* **Graphite** : The Graph panel no longer have a Graphite PNG option. closes [#5367](https://github.com/grafana/grafana/issues/5367)
+
+### Bug fixes
+* **PNG rendering**: Fixed phantomjs rendering and y-axis label rotation. fixes [#5220](https://github.com/grafana/grafana/issues/5220)
+* **CLI**: The cli tool now supports reading plugin.json from dist/plugin.json. fixes [#5410](https://github.com/grafana/grafana/issues/5410)
+
+# 3.0.4 Patch release (2016-05-25)
+* **Panel**: Fixed blank dashboard issue when switching to other dashboard while in fullscreen edit mode, fixes [#5163](https://github.com/grafana/grafana/pull/5163)
+* **Templating**: Fixed issue with nested multi select variables and cascading and updating child variable selection state, fixes [#4861](https://github.com/grafana/grafana/pull/4861)
+* **Templating**: Fixed issue with using templated data source in another template variable query, fixes [#5165](https://github.com/grafana/grafana/pull/5165)
+* **Singlestat gauge**: Fixed issue with gauge render position, fixes [#5143](https://github.com/grafana/grafana/pull/5143)
+* **Home dashboard**: Fixes broken home dashboard api, fixes [#5167](https://github.com/grafana/grafana/issues/5167)
+
+# 3.0.3 Patch release (2016-05-23)
+* **Annotations**: Annotations can now use a template variable as data source, closes [#5054](https://github.com/grafana/grafana/issues/5054)
+* **Time picker**: Fixed issue timepicker and UTC when reading time from URL, fixes [#5078](https://github.com/grafana/grafana/issues/5078)
+* **CloudWatch**: Support for Multiple Account by AssumeRole, closes [#3522](https://github.com/grafana/grafana/issues/3522)
+* **Singlestat**: Fixed alignment and minium height issue, fixes [#5113](https://github.com/grafana/grafana/issues/5113), fixes [#4679](https://github.com/grafana/grafana/issues/4679)
+* **Share modal**: Fixed link when using grafana under dashboard sub url, fixes [#5109](https://github.com/grafana/grafana/issues/5109)
+* **Prometheus**: Fixed bug in query editor that caused it not to load when reloading page, fixes [#5107](https://github.com/grafana/grafana/issues/5107)
+* **Elasticsearch**: Fixed bug when template variable query returns numeric values, fixes [#5097](https://github.com/grafana/grafana/issues/5097), fixes [#5088](https://github.com/grafana/grafana/issues/5088)
+* **Logging**: Fixed issue with reading logging level value, fixes [#5079](https://github.com/grafana/grafana/issues/5079)
+* **Timepicker**: Fixed issue with timepicker and UTC when reading time from URL, fixes [#5078](https://github.com/grafana/grafana/issues/5078)
+* **Docs**: Added docs for org & user preferences HTTP API, closes [#5069](https://github.com/grafana/grafana/issues/5069)
+* **Plugin list panel**: Now shows correct enable state for apps when not enabled, fixes [#5068](https://github.com/grafana/grafana/issues/5068)
+* **Elasticsearch**: Templating & Annotation queries that use template variables are now formatted correctly, fixes [#5135](https://github.com/grafana/grafana/issues/5135)
+
+# 3.0.2 Patch release (2016-05-16)
+
+* **Templating**: Fixed issue mixing row repeat and panel repeats, fixes [#4988](https://github.com/grafana/grafana/issues/4988)
+* **Templating**: Fixed issue detecting dependencies in nested variables, fixes [#4987](https://github.com/grafana/grafana/issues/4987), fixes [#4986](https://github.com/grafana/grafana/issues/4986)
+* **Graph**: Fixed broken PNG rendering in graph panel, fixes [#5025](https://github.com/grafana/grafana/issues/5025)
+* **Graph**: Fixed broken xaxis on graph panel, fixes [#5024](https://github.com/grafana/grafana/issues/5024)
+
+* **Influxdb**: Fixes crash when hiding middle serie, fixes [#5005](https://github.com/grafana/grafana/issues/5005)
+
+# 3.0.1 Stable (2016-05-11)
+
+### Bug fixes
+* **Templating**: Fixed issue with new data source variable not persisting current selected value, fixes [#4934](https://github.com/grafana/grafana/issues/4934)
+
+# 3.0.0-beta7 (2016-05-02)
+
+### Bug fixes
+* **Dashboard title**: Fixed max dashboard title width (media query) for large screens,  fixes [#4859](https://github.com/grafana/grafana/issues/4859)
+* **Annotations**: Fixed issue with entering annotation edit view, fixes [#4857](https://github.com/grafana/grafana/issues/4857)
+* **Remove query**: Fixed issue with removing query for data sources without collapsable query editors, fixes [#4856](https://github.com/grafana/grafana/issues/4856)
+* **Graphite PNG**: Fixed issue graphite png rendering option, fixes [#4864](https://github.com/grafana/grafana/issues/4864)
+* **InfluxDB**: Fixed issue missing plus group by iconn, fixes [#4862](https://github.com/grafana/grafana/issues/4862)
+* **Graph**: Fixes missing line mode for thresholds, fixes [#4902](https://github.com/grafana/grafana/pull/4902)
+
+### Enhancements
+* **InfluxDB**: Added new functions moving_average and difference to query editor, closes [#4698](https://github.com/grafana/grafana/issues/4698)
+
+# 3.0.0-beta6 (2016-04-29)
+
+### Enhancements
+* **Singlestat**: Support for gauges in singlestat panel. closes [#3688](https://github.com/grafana/grafana/pull/3688)
+* **Templating**: Support for data source as variable, closes [#816](https://github.com/grafana/grafana/pull/816)
+
+### Bug fixes
+* **InfluxDB 0.12**: Fixed issue templating and `show tag values` query only returning tags for first measurement,  fixes [#4726](https://github.com/grafana/grafana/issues/4726)
+* **Templating**: Fixed issue with regex formating when matching multiple values, fixes [#4755](https://github.com/grafana/grafana/issues/4755)
+* **Templating**: Fixed issue with custom all value and escaping, fixes [#4736](https://github.com/grafana/grafana/issues/4736)
+* **Dashlist**: Fixed issue dashboard list panel and caching tags, fixes [#4768](https://github.com/grafana/grafana/issues/4768)
+* **Graph**: Fixed issue with unneeded scrollbar in legend for Firefox, fixes [#4760](https://github.com/grafana/grafana/issues/4760)
+* **Table panel**: Fixed issue table panel formating string array properties, fixes [#4791](https://github.com/grafana/grafana/issues/4791)
+* **grafana-cli**: Improve error message when failing to install plugins due to corrupt response, fixes [#4651](https://github.com/grafana/grafana/issues/4651)
+* **Singlestat**: Fixes prefix an postfix for gauges, fixes [#4812](https://github.com/grafana/grafana/issues/4812)
+* **Singlestat**: Fixes auto-refresh on change for some options, fixes [#4809](https://github.com/grafana/grafana/issues/4809)
+
+### Breaking changes
+**Data Source Query Editors**: Issue [#3900](https://github.com/grafana/grafana/issues/3900)
+
+Query editors have been updated to use the new form styles. External data source plugins needs to be
+updated to work. Sorry to introduce breaking change this late in beta phase. We wanted to get this change
+in before 3.0 stable is released so we don't have to break data sources in next release (3.1). If you are
+a data source plugin author and want help for how the new form styles work please ask for help in
+slack channel (link to slack channel in readme).
+
+# 3.0.0-beta5 (2016-04-15)
+
+### Bug fixes
+* **grafana-cli**: Fixed issue grafana-cli tool, did not detect the right plugin dir, fixes [#4723](https://github.com/grafana/grafana/issues/4723)
+* **Graph**: Fixed issue with light theme text color issue in tooltip, fixes [#4702](https://github.com/grafana/grafana/issues/4702)
+* **Snapshot**: Fixed issue with empty snapshots, fixes [#4706](https://github.com/grafana/grafana/issues/4706)
+
+# 3.0.0-beta4 (2016-04-13)

 ### Bug fixes
 * **Home dashboard**: Fixed issue with permission denied error on home dashboard, fixes [#4686](https://github.com/grafana/grafana/issues/4686)
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -1,351 +0,0 @@
-{
-	"ImportPath": "github.com/grafana/grafana",
-	"GoVersion": "go1.5.1",
-	"GodepVersion": "v60",
-	"Packages": [
-		"./pkg/..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "github.com/BurntSushi/toml",
-			"Comment": "v0.1.0-21-g056c9bc",
-			"Rev": "056c9bc7be7190eaa7715723883caffa5f8fa3e4"
-		},
-		{
-			"ImportPath": "github.com/Unknwon/com",
-			"Rev": "d9bcf409c8a368d06c9b347705c381e7c12d54df"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/awserr",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/awsutil",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/client",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/client/metadata",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/corehandlers",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/defaults",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/ec2metadata",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/request",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/session",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/endpoints",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/ec2query",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query/queryutil",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/rest",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/signer/v4",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/waiter",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/service/cloudwatch",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/service/ec2",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/bmizerany/assert",
-			"Comment": "release.r60-6-ge17e998",
-			"Rev": "e17e99893cb6509f428e1728281c2ad60a6b31e3"
-		},
-		{
-			"ImportPath": "github.com/bradfitz/gomemcache/memcache",
-			"Comment": "release.r60-40-g72a6864",
-			"Rev": "72a68649ba712ee7c4b5b4a943a626bcd7d90eb8"
-		},
-		{
-			"ImportPath": "github.com/codegangsta/cli",
-			"Comment": "1.2.0-187-gc31a797",
-			"Rev": "c31a7975863e7810c92e2e288a9ab074f9a88f29"
-		},
-		{
-			"ImportPath": "github.com/davecgh/go-spew/spew",
-			"Rev": "2df174808ee097f90d259e432cc04442cf60be21"
-		},
-		{
-			"ImportPath": "github.com/fatih/color",
-			"Comment": "v0.1-16-g4f7bcef",
-			"Rev": "4f7bcef27eec7925456d0c30c5e7b0408b3339be"
-		},
-		{
-			"ImportPath": "github.com/franela/goreq",
-			"Rev": "3ddeded65be21dacb5a2e2d0b95af9ff6862a2b5"
-		},
-		{
-			"ImportPath": "github.com/go-ini/ini",
-			"Comment": "v0-48-g060d7da",
-			"Rev": "060d7da055ba6ec5ea7a31f116332fe5efa04ce0"
-		},
-		{
-			"ImportPath": "github.com/go-ldap/ldap",
-			"Comment": "v2.2.1",
-			"Rev": "07a7330929b9ee80495c88a4439657d89c7dbd87"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/binding",
-			"Rev": "2502aaf4bce3a4e6451b4610847bfb8dffdb6266"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/gzip",
-			"Rev": "4938e9be6b279d8426cb1c89a6bcf7af70b0c21d"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/inject",
-			"Rev": "c5ab7bf3a307593cd44cb272d1a5beea473dd072"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session/memcache",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session/mysql",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session/postgres",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session/redis",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-sql-driver/mysql",
-			"Comment": "v1.2-171-g267b128",
-			"Rev": "267b128680c46286b9ca13475c3cca5de8f79bd7"
-		},
-		{
-			"ImportPath": "github.com/go-xorm/core",
-			"Comment": "v0.4.4-7-g9e608f7",
-			"Rev": "9e608f7330b9d16fe2818cfe731128b3f156cb9a"
-		},
-		{
-			"ImportPath": "github.com/go-xorm/xorm",
-			"Comment": "v0.4.4-44-gf561133",
-			"Rev": "f56113384f2c63dfe4cd8e768e349f1c35122b58"
-		},
-		{
-			"ImportPath": "github.com/gorilla/websocket",
-			"Rev": "c45a635370221f34fea2d5163fd156fcb4e38e8a"
-		},
-		{
-			"ImportPath": "github.com/gosimple/slug",
-			"Rev": "8d258463b4459f161f51d6a357edacd3eef9d663"
-		},
-		{
-			"ImportPath": "github.com/hashicorp/go-version",
-			"Rev": "7e3c02b30806fa5779d3bdfc152ce4c6f40e7b38"
-		},
-		{
-			"ImportPath": "github.com/jmespath/go-jmespath",
-			"Comment": "0.2.2",
-			"Rev": "3433f3ea46d9f8019119e7dd41274e112a2359a9"
-		},
-		{
-			"ImportPath": "github.com/jtolds/gls",
-			"Rev": "f1ac7f4f24f50328e6bc838ca4437d1612a0243c"
-		},
-		{
-			"ImportPath": "github.com/klauspost/compress/flate",
-			"Rev": "7b02889a2005228347aef0e76beeaee564d82f8c"
-		},
-		{
-			"ImportPath": "github.com/klauspost/compress/gzip",
-			"Rev": "7b02889a2005228347aef0e76beeaee564d82f8c"
-		},
-		{
-			"ImportPath": "github.com/klauspost/cpuid",
-			"Rev": "349c675778172472f5e8f3a3e0fe187e302e5a10"
-		},
-		{
-			"ImportPath": "github.com/klauspost/crc32",
-			"Rev": "6834731faf32e62a2dd809d99fb24d1e4ae5a92d"
-		},
-		{
-			"ImportPath": "github.com/kr/pretty",
-			"Comment": "go.weekly.2011-12-22-27-ge6ac2fc",
-			"Rev": "e6ac2fc51e89a3249e82157fa0bb7a18ef9dd5bb"
-		},
-		{
-			"ImportPath": "github.com/kr/text",
-			"Rev": "bb797dc4fb8320488f47bf11de07a733d7233e1f"
-		},
-		{
-			"ImportPath": "github.com/lib/pq",
-			"Comment": "go1.0-cutoff-13-g19eeca3",
-			"Rev": "19eeca3e30d2577b1761db471ec130810e67f532"
-		},
-		{
-			"ImportPath": "github.com/lib/pq/oid",
-			"Comment": "go1.0-cutoff-13-g19eeca3",
-			"Rev": "19eeca3e30d2577b1761db471ec130810e67f532"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-colorable",
-			"Rev": "9cbef7c35391cca05f15f8181dc0b18bc9736dbb"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-isatty",
-			"Rev": "56b76bdf51f7708750eac80fa38b952bb9f32639"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-sqlite3",
-			"Rev": "e28cd440fabdd39b9520344bc26829f61db40ece"
-		},
-		{
-			"ImportPath": "github.com/rainycape/unidecode",
-			"Rev": "836ef0a715aedf08a12d595ed73ec8ed5b288cac"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey/assertions",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey/assertions/oglematchers",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey/gotest",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey/reporting",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/streadway/amqp",
-			"Rev": "150b7f24d6ad507e6026c13d85ce1f1391ac7400"
-		},
-		{
-			"ImportPath": "golang.org/x/net/context",
-			"Rev": "972f0c5fbe4ae29e666c3f78c3ed42ae7a448b0a"
-		},
-		{
-			"ImportPath": "golang.org/x/oauth2",
-			"Rev": "c58fcf0ffc1c772aa2e1ee4894bc19f2649263b2"
-		},
-		{
-			"ImportPath": "golang.org/x/sys/unix",
-			"Rev": "7a56174f0086b32866ebd746a794417edbc678a1"
-		},
-		{
-			"ImportPath": "gopkg.in/asn1-ber.v1",
-			"Comment": "v1",
-			"Rev": "9eae18c3681ae3d3c677ac2b80a8fe57de45fc09"
-		},
-		{
-			"ImportPath": "gopkg.in/bufio.v1",
-			"Comment": "v1",
-			"Rev": "567b2bfa514e796916c4747494d6ff5132a1dfce"
-		},
-		{
-			"ImportPath": "gopkg.in/ini.v1",
-			"Comment": "v0-16-g1772191",
-			"Rev": "177219109c97e7920c933e21c9b25f874357b237"
-		},
-		{
-			"ImportPath": "gopkg.in/macaron.v1",
-			"Rev": "1c6dd87797ae9319b4658cbd48d1d0420b279fd5"
-		},
-		{
-			"ImportPath": "gopkg.in/redis.v2",
-			"Comment": "v2.3.2",
-			"Rev": "e6179049628164864e6e84e973cfb56335748dea"
-		}
-	]
-}
--- a/Godeps/Readme
+++ b/Godeps/Readme
@@ -1,5 +0,0 @@
-This directory tree is generated automatically by godep.
-
-Please do not edit.
-
-See https://github.com/tools/godep for more information.
--- a/Godeps/_workspace/.gitignore
+++ b/Godeps/_workspace/.gitignore
@@ -1,2 +0,0 @@
-/pkg
-/bin
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/awsutil/copy_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/awsutil/copy_test.go
@@ -1,233 +0,0 @@
-package awsutil_test
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/awsutil"
-	"github.com/stretchr/testify/assert"
-)
-
-func ExampleCopy() {
-	type Foo struct {
-		A int
-		B []*string
-	}
-
-	// Create the initial value
-	str1 := "hello"
-	str2 := "bye bye"
-	f1 := &Foo{A: 1, B: []*string{&str1, &str2}}
-
-	// Do the copy
-	var f2 Foo
-	awsutil.Copy(&f2, f1)
-
-	// Print the result
-	fmt.Println(awsutil.Prettify(f2))
-
-	// Output:
-	// {
-	//   A: 1,
-	//   B: ["hello","bye bye"]
-	// }
-}
-
-func TestCopy(t *testing.T) {
-	type Foo struct {
-		A int
-		B []*string
-		C map[string]*int
-	}
-
-	// Create the initial value
-	str1 := "hello"
-	str2 := "bye bye"
-	int1 := 1
-	int2 := 2
-	f1 := &Foo{
-		A: 1,
-		B: []*string{&str1, &str2},
-		C: map[string]*int{
-			"A": &int1,
-			"B": &int2,
-		},
-	}
-
-	// Do the copy
-	var f2 Foo
-	awsutil.Copy(&f2, f1)
-
-	// Values are equal
-	assert.Equal(t, f2.A, f1.A)
-	assert.Equal(t, f2.B, f1.B)
-	assert.Equal(t, f2.C, f1.C)
-
-	// But pointers are not!
-	str3 := "nothello"
-	int3 := 57
-	f2.A = 100
-	f2.B[0] = &str3
-	f2.C["B"] = &int3
-	assert.NotEqual(t, f2.A, f1.A)
-	assert.NotEqual(t, f2.B, f1.B)
-	assert.NotEqual(t, f2.C, f1.C)
-}
-
-func TestCopyNestedWithUnexported(t *testing.T) {
-	type Bar struct {
-		a int
-		B int
-	}
-	type Foo struct {
-		A string
-		B Bar
-	}
-
-	f1 := &Foo{A: "string", B: Bar{a: 1, B: 2}}
-
-	var f2 Foo
-	awsutil.Copy(&f2, f1)
-
-	// Values match
-	assert.Equal(t, f2.A, f1.A)
-	assert.NotEqual(t, f2.B, f1.B)
-	assert.NotEqual(t, f2.B.a, f1.B.a)
-	assert.Equal(t, f2.B.B, f2.B.B)
-}
-
-func TestCopyIgnoreNilMembers(t *testing.T) {
-	type Foo struct {
-		A *string
-		B []string
-		C map[string]string
-	}
-
-	f := &Foo{}
-	assert.Nil(t, f.A)
-	assert.Nil(t, f.B)
-	assert.Nil(t, f.C)
-
-	var f2 Foo
-	awsutil.Copy(&f2, f)
-	assert.Nil(t, f2.A)
-	assert.Nil(t, f2.B)
-	assert.Nil(t, f2.C)
-
-	fcopy := awsutil.CopyOf(f)
-	f3 := fcopy.(*Foo)
-	assert.Nil(t, f3.A)
-	assert.Nil(t, f3.B)
-	assert.Nil(t, f3.C)
-}
-
-func TestCopyPrimitive(t *testing.T) {
-	str := "hello"
-	var s string
-	awsutil.Copy(&s, &str)
-	assert.Equal(t, "hello", s)
-}
-
-func TestCopyNil(t *testing.T) {
-	var s string
-	awsutil.Copy(&s, nil)
-	assert.Equal(t, "", s)
-}
-
-func TestCopyReader(t *testing.T) {
-	var buf io.Reader = bytes.NewReader([]byte("hello world"))
-	var r io.Reader
-	awsutil.Copy(&r, buf)
-	b, err := ioutil.ReadAll(r)
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("hello world"), b)
-
-	// empty bytes because this is not a deep copy
-	b, err = ioutil.ReadAll(buf)
-	assert.NoError(t, err)
-	assert.Equal(t, []byte(""), b)
-}
-
-func TestCopyDifferentStructs(t *testing.T) {
-	type SrcFoo struct {
-		A                int
-		B                []*string
-		C                map[string]*int
-		SrcUnique        string
-		SameNameDiffType int
-		unexportedPtr    *int
-		ExportedPtr      *int
-	}
-	type DstFoo struct {
-		A                int
-		B                []*string
-		C                map[string]*int
-		DstUnique        int
-		SameNameDiffType string
-		unexportedPtr    *int
-		ExportedPtr      *int
-	}
-
-	// Create the initial value
-	str1 := "hello"
-	str2 := "bye bye"
-	int1 := 1
-	int2 := 2
-	f1 := &SrcFoo{
-		A: 1,
-		B: []*string{&str1, &str2},
-		C: map[string]*int{
-			"A": &int1,
-			"B": &int2,
-		},
-		SrcUnique:        "unique",
-		SameNameDiffType: 1,
-		unexportedPtr:    &int1,
-		ExportedPtr:      &int2,
-	}
-
-	// Do the copy
-	var f2 DstFoo
-	awsutil.Copy(&f2, f1)
-
-	// Values are equal
-	assert.Equal(t, f2.A, f1.A)
-	assert.Equal(t, f2.B, f1.B)
-	assert.Equal(t, f2.C, f1.C)
-	assert.Equal(t, "unique", f1.SrcUnique)
-	assert.Equal(t, 1, f1.SameNameDiffType)
-	assert.Equal(t, 0, f2.DstUnique)
-	assert.Equal(t, "", f2.SameNameDiffType)
-	assert.Equal(t, int1, *f1.unexportedPtr)
-	assert.Nil(t, f2.unexportedPtr)
-	assert.Equal(t, int2, *f1.ExportedPtr)
-	assert.Equal(t, int2, *f2.ExportedPtr)
-}
-
-func ExampleCopyOf() {
-	type Foo struct {
-		A int
-		B []*string
-	}
-
-	// Create the initial value
-	str1 := "hello"
-	str2 := "bye bye"
-	f1 := &Foo{A: 1, B: []*string{&str1, &str2}}
-
-	// Do the copy
-	v := awsutil.CopyOf(f1)
-	var f2 *Foo = v.(*Foo)
-
-	// Print the result
-	fmt.Println(awsutil.Prettify(f2))
-
-	// Output:
-	// {
-	//   A: 1,
-	//   B: ["hello","bye bye"]
-	// }
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/awsutil/equal_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/awsutil/equal_test.go
@@ -1,29 +0,0 @@
-package awsutil_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awsutil"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestDeepEqual(t *testing.T) {
-	cases := []struct {
-		a, b  interface{}
-		equal bool
-	}{
-		{"a", "a", true},
-		{"a", "b", false},
-		{"a", aws.String(""), false},
-		{"a", nil, false},
-		{"a", aws.String("a"), true},
-		{(*bool)(nil), (*bool)(nil), true},
-		{(*bool)(nil), (*string)(nil), false},
-		{nil, nil, true},
-	}
-
-	for i, c := range cases {
-		assert.Equal(t, c.equal, awsutil.DeepEqual(c.a, c.b), "%d, a:%v b:%v, %t", i, c.a, c.b, c.equal)
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/awsutil/path_value_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/awsutil/path_value_test.go
@@ -1,142 +0,0 @@
-package awsutil_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/awsutil"
-	"github.com/stretchr/testify/assert"
-)
-
-type Struct struct {
-	A []Struct
-	z []Struct
-	B *Struct
-	D *Struct
-	C string
-	E map[string]string
-}
-
-var data = Struct{
-	A: []Struct{{C: "value1"}, {C: "value2"}, {C: "value3"}},
-	z: []Struct{{C: "value1"}, {C: "value2"}, {C: "value3"}},
-	B: &Struct{B: &Struct{C: "terminal"}, D: &Struct{C: "terminal2"}},
-	C: "initial",
-}
-var data2 = Struct{A: []Struct{
-	{A: []Struct{{C: "1"}, {C: "1"}, {C: "1"}, {C: "1"}, {C: "1"}}},
-	{A: []Struct{{C: "2"}, {C: "2"}, {C: "2"}, {C: "2"}, {C: "2"}}},
-}}
-
-func TestValueAtPathSuccess(t *testing.T) {
-	var testCases = []struct {
-		expect []interface{}
-		data   interface{}
-		path   string
-	}{
-		{[]interface{}{"initial"}, data, "C"},
-		{[]interface{}{"value1"}, data, "A[0].C"},
-		{[]interface{}{"value2"}, data, "A[1].C"},
-		{[]interface{}{"value3"}, data, "A[2].C"},
-		{[]interface{}{"value3"}, data, "a[2].c"},
-		{[]interface{}{"value3"}, data, "A[-1].C"},
-		{[]interface{}{"value1", "value2", "value3"}, data, "A[].C"},
-		{[]interface{}{"terminal"}, data, "B . B . C"},
-		{[]interface{}{"initial"}, data, "A.D.X || C"},
-		{[]interface{}{"initial"}, data, "A[0].B || C"},
-		{[]interface{}{
-			Struct{A: []Struct{{C: "1"}, {C: "1"}, {C: "1"}, {C: "1"}, {C: "1"}}},
-			Struct{A: []Struct{{C: "2"}, {C: "2"}, {C: "2"}, {C: "2"}, {C: "2"}}},
-		}, data2, "A"},
-	}
-	for i, c := range testCases {
-		v, err := awsutil.ValuesAtPath(c.data, c.path)
-		assert.NoError(t, err, "case %d, expected no error, %s", i, c.path)
-		assert.Equal(t, c.expect, v, "case %d, %s", i, c.path)
-	}
-}
-
-func TestValueAtPathFailure(t *testing.T) {
-	var testCases = []struct {
-		expect      []interface{}
-		errContains string
-		data        interface{}
-		path        string
-	}{
-		{nil, "", data, "C.x"},
-		{nil, "SyntaxError: Invalid token: tDot", data, ".x"},
-		{nil, "", data, "X.Y.Z"},
-		{nil, "", data, "A[100].C"},
-		{nil, "", data, "A[3].C"},
-		{nil, "", data, "B.B.C.Z"},
-		{nil, "", data, "z[-1].C"},
-		{nil, "", nil, "A.B.C"},
-		{[]interface{}{}, "", Struct{}, "A"},
-		{nil, "", data, "A[0].B.C"},
-		{nil, "", data, "D"},
-	}
-
-	for i, c := range testCases {
-		v, err := awsutil.ValuesAtPath(c.data, c.path)
-		if c.errContains != "" {
-			assert.Contains(t, err.Error(), c.errContains, "case %d, expected error, %s", i, c.path)
-			continue
-		} else {
-			assert.NoError(t, err, "case %d, expected no error, %s", i, c.path)
-		}
-		assert.Equal(t, c.expect, v, "case %d, %s", i, c.path)
-	}
-}
-
-func TestSetValueAtPathSuccess(t *testing.T) {
-	var s Struct
-	awsutil.SetValueAtPath(&s, "C", "test1")
-	awsutil.SetValueAtPath(&s, "B.B.C", "test2")
-	awsutil.SetValueAtPath(&s, "B.D.C", "test3")
-	assert.Equal(t, "test1", s.C)
-	assert.Equal(t, "test2", s.B.B.C)
-	assert.Equal(t, "test3", s.B.D.C)
-
-	awsutil.SetValueAtPath(&s, "B.*.C", "test0")
-	assert.Equal(t, "test0", s.B.B.C)
-	assert.Equal(t, "test0", s.B.D.C)
-
-	var s2 Struct
-	awsutil.SetValueAtPath(&s2, "b.b.c", "test0")
-	assert.Equal(t, "test0", s2.B.B.C)
-	awsutil.SetValueAtPath(&s2, "A", []Struct{{}})
-	assert.Equal(t, []Struct{{}}, s2.A)
-
-	str := "foo"
-
-	s3 := Struct{}
-	awsutil.SetValueAtPath(&s3, "b.b.c", str)
-	assert.Equal(t, "foo", s3.B.B.C)
-
-	s3 = Struct{B: &Struct{B: &Struct{C: str}}}
-	awsutil.SetValueAtPath(&s3, "b.b.c", nil)
-	assert.Equal(t, "", s3.B.B.C)
-
-	s3 = Struct{}
-	awsutil.SetValueAtPath(&s3, "b.b.c", nil)
-	assert.Equal(t, "", s3.B.B.C)
-
-	s3 = Struct{}
-	awsutil.SetValueAtPath(&s3, "b.b.c", &str)
-	assert.Equal(t, "foo", s3.B.B.C)
-
-	var s4 struct{ Name *string }
-	awsutil.SetValueAtPath(&s4, "Name", str)
-	assert.Equal(t, str, *s4.Name)
-
-	s4 = struct{ Name *string }{}
-	awsutil.SetValueAtPath(&s4, "Name", nil)
-	assert.Equal(t, (*string)(nil), s4.Name)
-
-	s4 = struct{ Name *string }{Name: &str}
-	awsutil.SetValueAtPath(&s4, "Name", nil)
-	assert.Equal(t, (*string)(nil), s4.Name)
-
-	s4 = struct{ Name *string }{}
-	awsutil.SetValueAtPath(&s4, "Name", &str)
-	assert.Equal(t, str, *s4.Name)
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/client/default_retryer.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/client/default_retryer.go
@@ -1,45 +0,0 @@
-package client
-
-import (
-	"math"
-	"math/rand"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-// DefaultRetryer implements basic retry logic using exponential backoff for
-// most services. If you want to implement custom retry logic, implement the
-// request.Retryer interface or create a structure type that composes this
-// struct and override the specific methods. For example, to override only
-// the MaxRetries method:
-//
-//		type retryer struct {
-//      service.DefaultRetryer
-//    }
-//
-//    // This implementation always has 100 max retries
-//    func (d retryer) MaxRetries() uint { return 100 }
-type DefaultRetryer struct {
-	NumMaxRetries int
-}
-
-// MaxRetries returns the number of maximum returns the service will use to make
-// an individual API request.
-func (d DefaultRetryer) MaxRetries() int {
-	return d.NumMaxRetries
-}
-
-// RetryRules returns the delay duration before retrying this request again
-func (d DefaultRetryer) RetryRules(r *request.Request) time.Duration {
-	delay := int(math.Pow(2, float64(r.RetryCount))) * (rand.Intn(30) + 30)
-	return time.Duration(delay) * time.Millisecond
-}
-
-// ShouldRetry returns if the request should be retried.
-func (d DefaultRetryer) ShouldRetry(r *request.Request) bool {
-	if r.HTTPResponse.StatusCode >= 500 {
-		return true
-	}
-	return r.IsErrorRetryable()
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/config_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/config_test.go
@@ -1,86 +0,0 @@
-package aws
-
-import (
-	"net/http"
-	"reflect"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/credentials"
-)
-
-var testCredentials = credentials.NewStaticCredentials("AKID", "SECRET", "SESSION")
-
-var copyTestConfig = Config{
-	Credentials:             testCredentials,
-	Endpoint:                String("CopyTestEndpoint"),
-	Region:                  String("COPY_TEST_AWS_REGION"),
-	DisableSSL:              Bool(true),
-	HTTPClient:              http.DefaultClient,
-	LogLevel:                LogLevel(LogDebug),
-	Logger:                  NewDefaultLogger(),
-	MaxRetries:              Int(3),
-	DisableParamValidation:  Bool(true),
-	DisableComputeChecksums: Bool(true),
-	S3ForcePathStyle:        Bool(true),
-}
-
-func TestCopy(t *testing.T) {
-	want := copyTestConfig
-	got := copyTestConfig.Copy()
-	if !reflect.DeepEqual(*got, want) {
-		t.Errorf("Copy() = %+v", got)
-		t.Errorf("    want %+v", want)
-	}
-
-	got.Region = String("other")
-	if got.Region == want.Region {
-		t.Errorf("Expect setting copy values not not reflect in source")
-	}
-}
-
-func TestCopyReturnsNewInstance(t *testing.T) {
-	want := copyTestConfig
-	got := copyTestConfig.Copy()
-	if got == &want {
-		t.Errorf("Copy() = %p; want different instance as source %p", got, &want)
-	}
-}
-
-var mergeTestZeroValueConfig = Config{}
-
-var mergeTestConfig = Config{
-	Credentials:             testCredentials,
-	Endpoint:                String("MergeTestEndpoint"),
-	Region:                  String("MERGE_TEST_AWS_REGION"),
-	DisableSSL:              Bool(true),
-	HTTPClient:              http.DefaultClient,
-	LogLevel:                LogLevel(LogDebug),
-	Logger:                  NewDefaultLogger(),
-	MaxRetries:              Int(10),
-	DisableParamValidation:  Bool(true),
-	DisableComputeChecksums: Bool(true),
-	S3ForcePathStyle:        Bool(true),
-}
-
-var mergeTests = []struct {
-	cfg  *Config
-	in   *Config
-	want *Config
-}{
-	{&Config{}, nil, &Config{}},
-	{&Config{}, &mergeTestZeroValueConfig, &Config{}},
-	{&Config{}, &mergeTestConfig, &mergeTestConfig},
-}
-
-func TestMerge(t *testing.T) {
-	for i, tt := range mergeTests {
-		got := tt.cfg.Copy()
-		got.MergeIn(tt.in)
-		if !reflect.DeepEqual(got, tt.want) {
-			t.Errorf("Config %d %+v", i, tt.cfg)
-			t.Errorf("   Merge(%+v)", tt.in)
-			t.Errorf("     got %+v", got)
-			t.Errorf("    want %+v", tt.want)
-		}
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/convert_types_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/convert_types_test.go
@@ -1,437 +0,0 @@
-package aws
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-var testCasesStringSlice = [][]string{
-	{"a", "b", "c", "d", "e"},
-	{"a", "b", "", "", "e"},
-}
-
-func TestStringSlice(t *testing.T) {
-	for idx, in := range testCasesStringSlice {
-		if in == nil {
-			continue
-		}
-		out := StringSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := StringValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesStringValueSlice = [][]*string{
-	{String("a"), String("b"), nil, String("c")},
-}
-
-func TestStringValueSlice(t *testing.T) {
-	for idx, in := range testCasesStringValueSlice {
-		if in == nil {
-			continue
-		}
-		out := StringValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := StringSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesStringMap = []map[string]string{
-	{"a": "1", "b": "2", "c": "3"},
-}
-
-func TestStringMap(t *testing.T) {
-	for idx, in := range testCasesStringMap {
-		if in == nil {
-			continue
-		}
-		out := StringMap(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := StringValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesBoolSlice = [][]bool{
-	{true, true, false, false},
-}
-
-func TestBoolSlice(t *testing.T) {
-	for idx, in := range testCasesBoolSlice {
-		if in == nil {
-			continue
-		}
-		out := BoolSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := BoolValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesBoolValueSlice = [][]*bool{}
-
-func TestBoolValueSlice(t *testing.T) {
-	for idx, in := range testCasesBoolValueSlice {
-		if in == nil {
-			continue
-		}
-		out := BoolValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := BoolSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesBoolMap = []map[string]bool{
-	{"a": true, "b": false, "c": true},
-}
-
-func TestBoolMap(t *testing.T) {
-	for idx, in := range testCasesBoolMap {
-		if in == nil {
-			continue
-		}
-		out := BoolMap(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := BoolValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesIntSlice = [][]int{
-	{1, 2, 3, 4},
-}
-
-func TestIntSlice(t *testing.T) {
-	for idx, in := range testCasesIntSlice {
-		if in == nil {
-			continue
-		}
-		out := IntSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := IntValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesIntValueSlice = [][]*int{}
-
-func TestIntValueSlice(t *testing.T) {
-	for idx, in := range testCasesIntValueSlice {
-		if in == nil {
-			continue
-		}
-		out := IntValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := IntSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesIntMap = []map[string]int{
-	{"a": 3, "b": 2, "c": 1},
-}
-
-func TestIntMap(t *testing.T) {
-	for idx, in := range testCasesIntMap {
-		if in == nil {
-			continue
-		}
-		out := IntMap(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := IntValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesInt64Slice = [][]int64{
-	{1, 2, 3, 4},
-}
-
-func TestInt64Slice(t *testing.T) {
-	for idx, in := range testCasesInt64Slice {
-		if in == nil {
-			continue
-		}
-		out := Int64Slice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := Int64ValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesInt64ValueSlice = [][]*int64{}
-
-func TestInt64ValueSlice(t *testing.T) {
-	for idx, in := range testCasesInt64ValueSlice {
-		if in == nil {
-			continue
-		}
-		out := Int64ValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := Int64Slice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesInt64Map = []map[string]int64{
-	{"a": 3, "b": 2, "c": 1},
-}
-
-func TestInt64Map(t *testing.T) {
-	for idx, in := range testCasesInt64Map {
-		if in == nil {
-			continue
-		}
-		out := Int64Map(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := Int64ValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesFloat64Slice = [][]float64{
-	{1, 2, 3, 4},
-}
-
-func TestFloat64Slice(t *testing.T) {
-	for idx, in := range testCasesFloat64Slice {
-		if in == nil {
-			continue
-		}
-		out := Float64Slice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := Float64ValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesFloat64ValueSlice = [][]*float64{}
-
-func TestFloat64ValueSlice(t *testing.T) {
-	for idx, in := range testCasesFloat64ValueSlice {
-		if in == nil {
-			continue
-		}
-		out := Float64ValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := Float64Slice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesFloat64Map = []map[string]float64{
-	{"a": 3, "b": 2, "c": 1},
-}
-
-func TestFloat64Map(t *testing.T) {
-	for idx, in := range testCasesFloat64Map {
-		if in == nil {
-			continue
-		}
-		out := Float64Map(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := Float64ValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesTimeSlice = [][]time.Time{
-	{time.Now(), time.Now().AddDate(100, 0, 0)},
-}
-
-func TestTimeSlice(t *testing.T) {
-	for idx, in := range testCasesTimeSlice {
-		if in == nil {
-			continue
-		}
-		out := TimeSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := TimeValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesTimeValueSlice = [][]*time.Time{}
-
-func TestTimeValueSlice(t *testing.T) {
-	for idx, in := range testCasesTimeValueSlice {
-		if in == nil {
-			continue
-		}
-		out := TimeValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := TimeSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesTimeMap = []map[string]time.Time{
-	{"a": time.Now().AddDate(-100, 0, 0), "b": time.Now()},
-}
-
-func TestTimeMap(t *testing.T) {
-	for idx, in := range testCasesTimeMap {
-		if in == nil {
-			continue
-		}
-		out := TimeMap(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := TimeValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/corehandlers/handlers_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/corehandlers/handlers_test.go
@@ -1,113 +0,0 @@
-package corehandlers_test
-
-import (
-	"fmt"
-	"net/http"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/corehandlers"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-)
-
-func TestValidateEndpointHandler(t *testing.T) {
-	os.Clearenv()
-
-	svc := awstesting.NewClient(aws.NewConfig().WithRegion("us-west-2"))
-	svc.Handlers.Clear()
-	svc.Handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler)
-
-	req := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil)
-	err := req.Build()
-
-	assert.NoError(t, err)
-}
-
-func TestValidateEndpointHandlerErrorRegion(t *testing.T) {
-	os.Clearenv()
-
-	svc := awstesting.NewClient()
-	svc.Handlers.Clear()
-	svc.Handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler)
-
-	req := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil)
-	err := req.Build()
-
-	assert.Error(t, err)
-	assert.Equal(t, aws.ErrMissingRegion, err)
-}
-
-type mockCredsProvider struct {
-	expired        bool
-	retrieveCalled bool
-}
-
-func (m *mockCredsProvider) Retrieve() (credentials.Value, error) {
-	m.retrieveCalled = true
-	return credentials.Value{}, nil
-}
-
-func (m *mockCredsProvider) IsExpired() bool {
-	return m.expired
-}
-
-func TestAfterRetryRefreshCreds(t *testing.T) {
-	os.Clearenv()
-	credProvider := &mockCredsProvider{}
-
-	svc := awstesting.NewClient(&aws.Config{
-		Credentials: credentials.NewCredentials(credProvider),
-		MaxRetries:  aws.Int(1),
-	})
-
-	svc.Handlers.Clear()
-	svc.Handlers.ValidateResponse.PushBack(func(r *request.Request) {
-		r.Error = awserr.New("UnknownError", "", nil)
-		r.HTTPResponse = &http.Response{StatusCode: 400}
-	})
-	svc.Handlers.UnmarshalError.PushBack(func(r *request.Request) {
-		r.Error = awserr.New("ExpiredTokenException", "", nil)
-	})
-	svc.Handlers.AfterRetry.PushBackNamed(corehandlers.AfterRetryHandler)
-
-	assert.True(t, svc.Config.Credentials.IsExpired(), "Expect to start out expired")
-	assert.False(t, credProvider.retrieveCalled)
-
-	req := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil)
-	req.Send()
-
-	assert.True(t, svc.Config.Credentials.IsExpired())
-	assert.False(t, credProvider.retrieveCalled)
-
-	_, err := svc.Config.Credentials.Get()
-	assert.NoError(t, err)
-	assert.True(t, credProvider.retrieveCalled)
-}
-
-type testSendHandlerTransport struct{}
-
-func (t *testSendHandlerTransport) RoundTrip(r *http.Request) (*http.Response, error) {
-	return nil, fmt.Errorf("mock error")
-}
-
-func TestSendHandlerError(t *testing.T) {
-	svc := awstesting.NewClient(&aws.Config{
-		HTTPClient: &http.Client{
-			Transport: &testSendHandlerTransport{},
-		},
-	})
-	svc.Handlers.Clear()
-	svc.Handlers.Send.PushBackNamed(corehandlers.SendHandler)
-	r := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil)
-
-	r.Send()
-
-	assert.Error(t, r.Error)
-	assert.NotNil(t, r.HTTPResponse)
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go
@@ -1,144 +0,0 @@
-package corehandlers
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-// ValidateParametersHandler is a request handler to validate the input parameters.
-// Validating parameters only has meaning if done prior to the request being sent.
-var ValidateParametersHandler = request.NamedHandler{Name: "core.ValidateParametersHandler", Fn: func(r *request.Request) {
-	if r.ParamsFilled() {
-		v := validator{errors: []string{}}
-		v.validateAny(reflect.ValueOf(r.Params), "")
-
-		if count := len(v.errors); count > 0 {
-			format := "%d validation errors:\n- %s"
-			msg := fmt.Sprintf(format, count, strings.Join(v.errors, "\n- "))
-			r.Error = awserr.New("InvalidParameter", msg, nil)
-		}
-	}
-}}
-
-// A validator validates values. Collects validations errors which occurs.
-type validator struct {
-	errors []string
-}
-
-// validateAny will validate any struct, slice or map type. All validations
-// are also performed recursively for nested types.
-func (v *validator) validateAny(value reflect.Value, path string) {
-	value = reflect.Indirect(value)
-	if !value.IsValid() {
-		return
-	}
-
-	switch value.Kind() {
-	case reflect.Struct:
-		v.validateStruct(value, path)
-	case reflect.Slice:
-		for i := 0; i < value.Len(); i++ {
-			v.validateAny(value.Index(i), path+fmt.Sprintf("[%d]", i))
-		}
-	case reflect.Map:
-		for _, n := range value.MapKeys() {
-			v.validateAny(value.MapIndex(n), path+fmt.Sprintf("[%q]", n.String()))
-		}
-	}
-}
-
-// validateStruct will validate the struct value's fields. If the structure has
-// nested types those types will be validated also.
-func (v *validator) validateStruct(value reflect.Value, path string) {
-	prefix := "."
-	if path == "" {
-		prefix = ""
-	}
-
-	for i := 0; i < value.Type().NumField(); i++ {
-		f := value.Type().Field(i)
-		if strings.ToLower(f.Name[0:1]) == f.Name[0:1] {
-			continue
-		}
-		fvalue := value.FieldByName(f.Name)
-
-		err := validateField(f, fvalue, validateFieldRequired, validateFieldMin)
-		if err != nil {
-			v.errors = append(v.errors, fmt.Sprintf("%s: %s", err.Error(), path+prefix+f.Name))
-			continue
-		}
-
-		v.validateAny(fvalue, path+prefix+f.Name)
-	}
-}
-
-type validatorFunc func(f reflect.StructField, fvalue reflect.Value) error
-
-func validateField(f reflect.StructField, fvalue reflect.Value, funcs ...validatorFunc) error {
-	for _, fn := range funcs {
-		if err := fn(f, fvalue); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Validates that a field has a valid value provided for required fields.
-func validateFieldRequired(f reflect.StructField, fvalue reflect.Value) error {
-	if f.Tag.Get("required") == "" {
-		return nil
-	}
-
-	switch fvalue.Kind() {
-	case reflect.Ptr, reflect.Slice, reflect.Map:
-		if fvalue.IsNil() {
-			return fmt.Errorf("missing required parameter")
-		}
-	default:
-		if !fvalue.IsValid() {
-			return fmt.Errorf("missing required parameter")
-		}
-	}
-	return nil
-}
-
-// Validates that if a value is provided for a field, that value must be at
-// least a minimum length.
-func validateFieldMin(f reflect.StructField, fvalue reflect.Value) error {
-	minStr := f.Tag.Get("min")
-	if minStr == "" {
-		return nil
-	}
-	min, _ := strconv.ParseInt(minStr, 10, 64)
-
-	kind := fvalue.Kind()
-	if kind == reflect.Ptr {
-		if fvalue.IsNil() {
-			return nil
-		}
-		fvalue = fvalue.Elem()
-	}
-
-	switch fvalue.Kind() {
-	case reflect.String:
-		if int64(fvalue.Len()) < min {
-			return fmt.Errorf("field too short, minimum length %d", min)
-		}
-	case reflect.Slice, reflect.Map:
-		if fvalue.IsNil() {
-			return nil
-		}
-		if int64(fvalue.Len()) < min {
-			return fmt.Errorf("field too short, minimum length %d", min)
-		}
-
-		// TODO min can also apply to number minimum value.
-
-	}
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator_test.go
@@ -1,134 +0,0 @@
-package corehandlers_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/aws/client/metadata"
-	"github.com/aws/aws-sdk-go/aws/corehandlers"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/stretchr/testify/require"
-)
-
-var testSvc = func() *client.Client {
-	s := &client.Client{
-		Config: aws.Config{},
-		ClientInfo: metadata.ClientInfo{
-			ServiceName: "mock-service",
-			APIVersion:  "2015-01-01",
-		},
-	}
-	return s
-}()
-
-type StructShape struct {
-	RequiredList   []*ConditionalStructShape          `required:"true"`
-	RequiredMap    map[string]*ConditionalStructShape `required:"true"`
-	RequiredBool   *bool                              `required:"true"`
-	OptionalStruct *ConditionalStructShape
-
-	hiddenParameter *string
-
-	metadataStructureShape
-}
-
-type metadataStructureShape struct {
-	SDKShapeTraits bool
-}
-
-type ConditionalStructShape struct {
-	Name           *string `required:"true"`
-	SDKShapeTraits bool
-}
-
-func TestNoErrors(t *testing.T) {
-	input := &StructShape{
-		RequiredList: []*ConditionalStructShape{},
-		RequiredMap: map[string]*ConditionalStructShape{
-			"key1": {Name: aws.String("Name")},
-			"key2": {Name: aws.String("Name")},
-		},
-		RequiredBool:   aws.Bool(true),
-		OptionalStruct: &ConditionalStructShape{Name: aws.String("Name")},
-	}
-
-	req := testSvc.NewRequest(&request.Operation{}, input, nil)
-	corehandlers.ValidateParametersHandler.Fn(req)
-	require.NoError(t, req.Error)
-}
-
-func TestMissingRequiredParameters(t *testing.T) {
-	input := &StructShape{}
-	req := testSvc.NewRequest(&request.Operation{}, input, nil)
-	corehandlers.ValidateParametersHandler.Fn(req)
-
-	require.Error(t, req.Error)
-	assert.Equal(t, "InvalidParameter", req.Error.(awserr.Error).Code())
-	assert.Equal(t, "3 validation errors:\n- missing required parameter: RequiredList\n- missing required parameter: RequiredMap\n- missing required parameter: RequiredBool", req.Error.(awserr.Error).Message())
-}
-
-func TestNestedMissingRequiredParameters(t *testing.T) {
-	input := &StructShape{
-		RequiredList: []*ConditionalStructShape{{}},
-		RequiredMap: map[string]*ConditionalStructShape{
-			"key1": {Name: aws.String("Name")},
-			"key2": {},
-		},
-		RequiredBool:   aws.Bool(true),
-		OptionalStruct: &ConditionalStructShape{},
-	}
-
-	req := testSvc.NewRequest(&request.Operation{}, input, nil)
-	corehandlers.ValidateParametersHandler.Fn(req)
-
-	require.Error(t, req.Error)
-	assert.Equal(t, "InvalidParameter", req.Error.(awserr.Error).Code())
-	assert.Equal(t, "3 validation errors:\n- missing required parameter: RequiredList[0].Name\n- missing required parameter: RequiredMap[\"key2\"].Name\n- missing required parameter: OptionalStruct.Name", req.Error.(awserr.Error).Message())
-}
-
-type testInput struct {
-	StringField string            `min:"5"`
-	PtrStrField *string           `min:"2"`
-	ListField   []string          `min:"3"`
-	MapField    map[string]string `min:"4"`
-}
-
-var testsFieldMin = []struct {
-	err awserr.Error
-	in  testInput
-}{
-	{
-		err: awserr.New("InvalidParameter", "1 validation errors:\n- field too short, minimum length 5: StringField", nil),
-		in:  testInput{StringField: "abcd"},
-	},
-	{
-		err: awserr.New("InvalidParameter", "2 validation errors:\n- field too short, minimum length 5: StringField\n- field too short, minimum length 3: ListField", nil),
-		in:  testInput{StringField: "abcd", ListField: []string{"a", "b"}},
-	},
-	{
-		err: awserr.New("InvalidParameter", "3 validation errors:\n- field too short, minimum length 5: StringField\n- field too short, minimum length 3: ListField\n- field too short, minimum length 4: MapField", nil),
-		in:  testInput{StringField: "abcd", ListField: []string{"a", "b"}, MapField: map[string]string{"a": "a", "b": "b"}},
-	},
-	{
-		err: awserr.New("InvalidParameter", "1 validation errors:\n- field too short, minimum length 2: PtrStrField", nil),
-		in:  testInput{StringField: "abcde", PtrStrField: aws.String("v")},
-	},
-	{
-		err: nil,
-		in: testInput{StringField: "abcde", PtrStrField: aws.String("value"),
-			ListField: []string{"a", "b", "c"}, MapField: map[string]string{"a": "a", "b": "b", "c": "c", "d": "d"}},
-	},
-}
-
-func TestValidateFieldMinParameter(t *testing.T) {
-	for i, c := range testsFieldMin {
-		req := testSvc.NewRequest(&request.Operation{}, &c.in, nil)
-		corehandlers.ValidateParametersHandler.Fn(req)
-
-		require.Equal(t, c.err, req.Error, "%d case failed", i)
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/chain_provider_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/chain_provider_test.go
@@ -1,73 +0,0 @@
-package credentials
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestChainProviderGet(t *testing.T) {
-	p := &ChainProvider{
-		Providers: []Provider{
-			&stubProvider{err: awserr.New("FirstError", "first provider error", nil)},
-			&stubProvider{err: awserr.New("SecondError", "second provider error", nil)},
-			&stubProvider{
-				creds: Value{
-					AccessKeyID:     "AKID",
-					SecretAccessKey: "SECRET",
-					SessionToken:    "",
-				},
-			},
-		},
-	}
-
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-	assert.Equal(t, "AKID", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "SECRET", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect session token to be empty")
-}
-
-func TestChainProviderIsExpired(t *testing.T) {
-	stubProvider := &stubProvider{expired: true}
-	p := &ChainProvider{
-		Providers: []Provider{
-			stubProvider,
-		},
-	}
-
-	assert.True(t, p.IsExpired(), "Expect expired to be true before any Retrieve")
-	_, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-	assert.False(t, p.IsExpired(), "Expect not expired after retrieve")
-
-	stubProvider.expired = true
-	assert.True(t, p.IsExpired(), "Expect return of expired provider")
-
-	_, err = p.Retrieve()
-	assert.False(t, p.IsExpired(), "Expect not expired after retrieve")
-}
-
-func TestChainProviderWithNoProvider(t *testing.T) {
-	p := &ChainProvider{
-		Providers: []Provider{},
-	}
-
-	assert.True(t, p.IsExpired(), "Expect expired with no providers")
-	_, err := p.Retrieve()
-	assert.Equal(t, ErrNoValidProvidersFoundInChain, err, "Expect no providers error returned")
-}
-
-func TestChainProviderWithNoValidProvider(t *testing.T) {
-	p := &ChainProvider{
-		Providers: []Provider{
-			&stubProvider{err: awserr.New("FirstError", "first provider error", nil)},
-			&stubProvider{err: awserr.New("SecondError", "second provider error", nil)},
-		},
-	}
-
-	assert.True(t, p.IsExpired(), "Expect expired with no providers")
-	_, err := p.Retrieve()
-	assert.Equal(t, ErrNoValidProvidersFoundInChain, err, "Expect no providers error returned")
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/credentials_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/credentials_test.go
@@ -1,62 +0,0 @@
-package credentials
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/stretchr/testify/assert"
-)
-
-type stubProvider struct {
-	creds   Value
-	expired bool
-	err     error
-}
-
-func (s *stubProvider) Retrieve() (Value, error) {
-	s.expired = false
-	return s.creds, s.err
-}
-func (s *stubProvider) IsExpired() bool {
-	return s.expired
-}
-
-func TestCredentialsGet(t *testing.T) {
-	c := NewCredentials(&stubProvider{
-		creds: Value{
-			AccessKeyID:     "AKID",
-			SecretAccessKey: "SECRET",
-			SessionToken:    "",
-		},
-		expired: true,
-	})
-
-	creds, err := c.Get()
-	assert.Nil(t, err, "Expected no error")
-	assert.Equal(t, "AKID", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "SECRET", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect session token to be empty")
-}
-
-func TestCredentialsGetWithError(t *testing.T) {
-	c := NewCredentials(&stubProvider{err: awserr.New("provider error", "", nil), expired: true})
-
-	_, err := c.Get()
-	assert.Equal(t, "provider error", err.(awserr.Error).Code(), "Expected provider error")
-}
-
-func TestCredentialsExpire(t *testing.T) {
-	stub := &stubProvider{}
-	c := NewCredentials(stub)
-
-	stub.expired = false
-	assert.True(t, c.IsExpired(), "Expected to start out expired")
-	c.Expire()
-	assert.True(t, c.IsExpired(), "Expected to be expired")
-
-	c.forceRefresh = false
-	assert.False(t, c.IsExpired(), "Expected not to be expired")
-
-	stub.expired = true
-	assert.True(t, c.IsExpired(), "Expected to be expired")
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds/ec2_role_provider_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds/ec2_role_provider_test.go
@@ -1,159 +0,0 @@
-package ec2rolecreds_test
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"
-	"github.com/aws/aws-sdk-go/aws/ec2metadata"
-	"github.com/aws/aws-sdk-go/aws/session"
-)
-
-const credsRespTmpl = `{
-  "Code": "Success",
-  "Type": "AWS-HMAC",
-  "AccessKeyId" : "accessKey",
-  "SecretAccessKey" : "secret",
-  "Token" : "token",
-  "Expiration" : "%s",
-  "LastUpdated" : "2009-11-23T0:00:00Z"
-}`
-
-const credsFailRespTmpl = `{
-  "Code": "ErrorCode",
-  "Message": "ErrorMsg",
-  "LastUpdated": "2009-11-23T0:00:00Z"
-}`
-
-func initTestServer(expireOn string, failAssume bool) *httptest.Server {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/latest/meta-data/iam/security-credentials" {
-			fmt.Fprintln(w, "RoleName")
-		} else if r.URL.Path == "/latest/meta-data/iam/security-credentials/RoleName" {
-			if failAssume {
-				fmt.Fprintf(w, credsFailRespTmpl)
-			} else {
-				fmt.Fprintf(w, credsRespTmpl, expireOn)
-			}
-		} else {
-			http.Error(w, "bad request", http.StatusBadRequest)
-		}
-	}))
-
-	return server
-}
-
-func TestEC2RoleProvider(t *testing.T) {
-	server := initTestServer("2014-12-16T01:51:37Z", false)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client: ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")}),
-	}
-
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error, %v", err)
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "token", creds.SessionToken, "Expect session token to match")
-}
-
-func TestEC2RoleProviderFailAssume(t *testing.T) {
-	server := initTestServer("2014-12-16T01:51:37Z", true)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client: ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")}),
-	}
-
-	creds, err := p.Retrieve()
-	assert.Error(t, err, "Expect error")
-
-	e := err.(awserr.Error)
-	assert.Equal(t, "ErrorCode", e.Code())
-	assert.Equal(t, "ErrorMsg", e.Message())
-	assert.Nil(t, e.OrigErr())
-
-	assert.Equal(t, "", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "", creds.SessionToken, "Expect session token to match")
-}
-
-func TestEC2RoleProviderIsExpired(t *testing.T) {
-	server := initTestServer("2014-12-16T01:51:37Z", false)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client: ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")}),
-	}
-	p.CurrentTime = func() time.Time {
-		return time.Date(2014, 12, 15, 21, 26, 0, 0, time.UTC)
-	}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired before retrieve.")
-
-	_, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error, %v", err)
-
-	assert.False(t, p.IsExpired(), "Expect creds to not be expired after retrieve.")
-
-	p.CurrentTime = func() time.Time {
-		return time.Date(3014, 12, 15, 21, 26, 0, 0, time.UTC)
-	}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired.")
-}
-
-func TestEC2RoleProviderExpiryWindowIsExpired(t *testing.T) {
-	server := initTestServer("2014-12-16T01:51:37Z", false)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client:       ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")}),
-		ExpiryWindow: time.Hour * 1,
-	}
-	p.CurrentTime = func() time.Time {
-		return time.Date(2014, 12, 15, 0, 51, 37, 0, time.UTC)
-	}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired before retrieve.")
-
-	_, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error, %v", err)
-
-	assert.False(t, p.IsExpired(), "Expect creds to not be expired after retrieve.")
-
-	p.CurrentTime = func() time.Time {
-		return time.Date(2014, 12, 16, 0, 55, 37, 0, time.UTC)
-	}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired.")
-}
-
-func BenchmarkEC3RoleProvider(b *testing.B) {
-	server := initTestServer("2014-12-16T01:51:37Z", false)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client: ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")}),
-	}
-	_, err := p.Retrieve()
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		if _, err := p.Retrieve(); err != nil {
-			b.Fatal(err)
-		}
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/env_provider_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/env_provider_test.go
@@ -1,70 +0,0 @@
-package credentials
-
-import (
-	"github.com/stretchr/testify/assert"
-	"os"
-	"testing"
-)
-
-func TestEnvProviderRetrieve(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_ACCESS_KEY_ID", "access")
-	os.Setenv("AWS_SECRET_ACCESS_KEY", "secret")
-	os.Setenv("AWS_SESSION_TOKEN", "token")
-
-	e := EnvProvider{}
-	creds, err := e.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "access", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "token", creds.SessionToken, "Expect session token to match")
-}
-
-func TestEnvProviderIsExpired(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_ACCESS_KEY_ID", "access")
-	os.Setenv("AWS_SECRET_ACCESS_KEY", "secret")
-	os.Setenv("AWS_SESSION_TOKEN", "token")
-
-	e := EnvProvider{}
-
-	assert.True(t, e.IsExpired(), "Expect creds to be expired before retrieve.")
-
-	_, err := e.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.False(t, e.IsExpired(), "Expect creds to not be expired after retrieve.")
-}
-
-func TestEnvProviderNoAccessKeyID(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_SECRET_ACCESS_KEY", "secret")
-
-	e := EnvProvider{}
-	creds, err := e.Retrieve()
-	assert.Equal(t, ErrAccessKeyIDNotFound, err, "ErrAccessKeyIDNotFound expected, but was %#v error: %#v", creds, err)
-}
-
-func TestEnvProviderNoSecretAccessKey(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_ACCESS_KEY_ID", "access")
-
-	e := EnvProvider{}
-	creds, err := e.Retrieve()
-	assert.Equal(t, ErrSecretAccessKeyNotFound, err, "ErrSecretAccessKeyNotFound expected, but was %#v error: %#v", creds, err)
-}
-
-func TestEnvProviderAlternateNames(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_ACCESS_KEY", "access")
-	os.Setenv("AWS_SECRET_KEY", "secret")
-
-	e := EnvProvider{}
-	creds, err := e.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "access", creds.AccessKeyID, "Expected access key ID")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expected secret access key")
-	assert.Empty(t, creds.SessionToken, "Expected no token")
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/shared_credentials_provider_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/shared_credentials_provider_test.go
@@ -1,100 +0,0 @@
-package credentials
-
-import (
-	"github.com/stretchr/testify/assert"
-	"os"
-	"testing"
-)
-
-func TestSharedCredentialsProvider(t *testing.T) {
-	os.Clearenv()
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""}
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "token", creds.SessionToken, "Expect session token to match")
-}
-
-func TestSharedCredentialsProviderIsExpired(t *testing.T) {
-	os.Clearenv()
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired before retrieve")
-
-	_, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.False(t, p.IsExpired(), "Expect creds to not be expired after retrieve")
-}
-
-func TestSharedCredentialsProviderWithAWS_SHARED_CREDENTIALS_FILE(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_SHARED_CREDENTIALS_FILE", "example.ini")
-	p := SharedCredentialsProvider{}
-	creds, err := p.Retrieve()
-
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "token", creds.SessionToken, "Expect session token to match")
-}
-
-func TestSharedCredentialsProviderWithAWS_PROFILE(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_PROFILE", "no_token")
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""}
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect no token")
-}
-
-func TestSharedCredentialsProviderWithoutTokenFromProfile(t *testing.T) {
-	os.Clearenv()
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: "no_token"}
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect no token")
-}
-
-func TestSharedCredentialsProviderColonInCredFile(t *testing.T) {
-	os.Clearenv()
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: "with_colon"}
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect no token")
-}
-
-func BenchmarkSharedCredentialsProvider(b *testing.B) {
-	os.Clearenv()
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""}
-	_, err := p.Retrieve()
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, err := p.Retrieve()
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/static_provider_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/static_provider_test.go
@@ -1,34 +0,0 @@
-package credentials
-
-import (
-	"github.com/stretchr/testify/assert"
-	"testing"
-)
-
-func TestStaticProviderGet(t *testing.T) {
-	s := StaticProvider{
-		Value: Value{
-			AccessKeyID:     "AKID",
-			SecretAccessKey: "SECRET",
-			SessionToken:    "",
-		},
-	}
-
-	creds, err := s.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-	assert.Equal(t, "AKID", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "SECRET", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect no session token")
-}
-
-func TestStaticProviderIsExpired(t *testing.T) {
-	s := StaticProvider{
-		Value: Value{
-			AccessKeyID:     "AKID",
-			SecretAccessKey: "SECRET",
-			SessionToken:    "",
-		},
-	}
-
-	assert.False(t, s.IsExpired(), "Expect static credentials to never expire")
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider_test.go
@@ -1,56 +0,0 @@
-package stscreds
-
-import (
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/sts"
-	"github.com/stretchr/testify/assert"
-)
-
-type stubSTS struct {
-}
-
-func (s *stubSTS) AssumeRole(input *sts.AssumeRoleInput) (*sts.AssumeRoleOutput, error) {
-	expiry := time.Now().Add(60 * time.Minute)
-	return &sts.AssumeRoleOutput{
-		Credentials: &sts.Credentials{
-			// Just reflect the role arn to the provider.
-			AccessKeyId:     input.RoleArn,
-			SecretAccessKey: aws.String("assumedSecretAccessKey"),
-			SessionToken:    aws.String("assumedSessionToken"),
-			Expiration:      &expiry,
-		},
-	}, nil
-}
-
-func TestAssumeRoleProvider(t *testing.T) {
-	stub := &stubSTS{}
-	p := &AssumeRoleProvider{
-		Client:  stub,
-		RoleARN: "roleARN",
-	}
-
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "roleARN", creds.AccessKeyID, "Expect access key ID to be reflected role ARN")
-	assert.Equal(t, "assumedSecretAccessKey", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "assumedSessionToken", creds.SessionToken, "Expect session token to match")
-}
-
-func BenchmarkAssumeRoleProvider(b *testing.B) {
-	stub := &stubSTS{}
-	p := &AssumeRoleProvider{
-		Client:  stub,
-		RoleARN: "roleARN",
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		if _, err := p.Retrieve(); err != nil {
-			b.Fatal(err)
-		}
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/defaults/defaults.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/defaults/defaults.go
@@ -1,76 +0,0 @@
-// Package defaults is a collection of helpers to retrieve the SDK's default
-// configuration and handlers.
-package defaults
-
-import (
-	"net/http"
-	"os"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/corehandlers"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"
-	"github.com/aws/aws-sdk-go/aws/ec2metadata"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/endpoints"
-)
-
-// A Defaults provides a collection of default values for SDK clients.
-type Defaults struct {
-	Config   *aws.Config
-	Handlers request.Handlers
-}
-
-// Get returns the SDK's default values with Config and handlers pre-configured.
-func Get() Defaults {
-	cfg := Config()
-	handlers := Handlers()
-	cfg.Credentials = CredChain(cfg, handlers)
-
-	return Defaults{
-		Config:   cfg,
-		Handlers: handlers,
-	}
-}
-
-// Config returns the default configuration.
-func Config() *aws.Config {
-	return aws.NewConfig().
-		WithCredentials(credentials.AnonymousCredentials).
-		WithRegion(os.Getenv("AWS_REGION")).
-		WithHTTPClient(http.DefaultClient).
-		WithMaxRetries(aws.UseServiceDefaultRetries).
-		WithLogger(aws.NewDefaultLogger()).
-		WithLogLevel(aws.LogOff).
-		WithSleepDelay(time.Sleep)
-}
-
-// Handlers returns the default request handlers.
-func Handlers() request.Handlers {
-	var handlers request.Handlers
-
-	handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler)
-	handlers.Build.PushBackNamed(corehandlers.SDKVersionUserAgentHandler)
-	handlers.Sign.PushBackNamed(corehandlers.BuildContentLengthHandler)
-	handlers.Send.PushBackNamed(corehandlers.SendHandler)
-	handlers.AfterRetry.PushBackNamed(corehandlers.AfterRetryHandler)
-	handlers.ValidateResponse.PushBackNamed(corehandlers.ValidateResponseHandler)
-
-	return handlers
-}
-
-// CredChain returns the default credential chain.
-func CredChain(cfg *aws.Config, handlers request.Handlers) *credentials.Credentials {
-	endpoint, signingRegion := endpoints.EndpointForRegion(ec2metadata.ServiceName, *cfg.Region, true)
-
-	return credentials.NewChainCredentials(
-		[]credentials.Provider{
-			&credentials.EnvProvider{},
-			&credentials.SharedCredentialsProvider{Filename: "", Profile: ""},
-			&ec2rolecreds.EC2RoleProvider{
-				Client:       ec2metadata.NewClient(*cfg, handlers, endpoint, signingRegion),
-				ExpiryWindow: 5 * time.Minute,
-			},
-		})
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/ec2metadata/api.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/ec2metadata/api.go
@@ -1,43 +0,0 @@
-package ec2metadata
-
-import (
-	"path"
-
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-// GetMetadata uses the path provided to request
-func (c *EC2Metadata) GetMetadata(p string) (string, error) {
-	op := &request.Operation{
-		Name:       "GetMetadata",
-		HTTPMethod: "GET",
-		HTTPPath:   path.Join("/", "meta-data", p),
-	}
-
-	output := &metadataOutput{}
-	req := c.NewRequest(op, nil, output)
-
-	return output.Content, req.Send()
-}
-
-// Region returns the region the instance is running in.
-func (c *EC2Metadata) Region() (string, error) {
-	resp, err := c.GetMetadata("placement/availability-zone")
-	if err != nil {
-		return "", err
-	}
-
-	// returns region without the suffix. Eg: us-west-2a becomes us-west-2
-	return resp[:len(resp)-1], nil
-}
-
-// Available returns if the application has access to the EC2 Metadata service.
-// Can be used to determine if application is running within an EC2 Instance and
-// the metadata service is available.
-func (c *EC2Metadata) Available() bool {
-	if _, err := c.GetMetadata("instance-id"); err != nil {
-		return false
-	}
-
-	return true
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/ec2metadata/api_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/ec2metadata/api_test.go
@@ -1,101 +0,0 @@
-package ec2metadata_test
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"path"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/ec2metadata"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/aws/session"
-)
-
-func initTestServer(path string, resp string) *httptest.Server {
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.RequestURI != path {
-			http.Error(w, "not found", http.StatusNotFound)
-			return
-		}
-
-		w.Write([]byte(resp))
-	}))
-}
-
-func TestEndpoint(t *testing.T) {
-	c := ec2metadata.New(session.New())
-	op := &request.Operation{
-		Name:       "GetMetadata",
-		HTTPMethod: "GET",
-		HTTPPath:   path.Join("/", "meta-data", "testpath"),
-	}
-
-	req := c.NewRequest(op, nil, nil)
-	assert.Equal(t, "http://169.254.169.254/latest", req.ClientInfo.Endpoint)
-	assert.Equal(t, "http://169.254.169.254/latest/meta-data/testpath", req.HTTPRequest.URL.String())
-}
-
-func TestGetMetadata(t *testing.T) {
-	server := initTestServer(
-		"/latest/meta-data/some/path",
-		"success", // real response includes suffix
-	)
-	defer server.Close()
-	c := ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")})
-
-	resp, err := c.GetMetadata("some/path")
-
-	assert.NoError(t, err)
-	assert.Equal(t, "success", resp)
-}
-
-func TestGetRegion(t *testing.T) {
-	server := initTestServer(
-		"/latest/meta-data/placement/availability-zone",
-		"us-west-2a", // real response includes suffix
-	)
-	defer server.Close()
-	c := ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")})
-
-	region, err := c.Region()
-
-	assert.NoError(t, err)
-	assert.Equal(t, "us-west-2", region)
-}
-
-func TestMetadataAvailable(t *testing.T) {
-	server := initTestServer(
-		"/latest/meta-data/instance-id",
-		"instance-id",
-	)
-	defer server.Close()
-	c := ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")})
-
-	available := c.Available()
-
-	assert.True(t, available)
-}
-
-func TestMetadataNotAvailable(t *testing.T) {
-	c := ec2metadata.New(session.New())
-	c.Handlers.Send.Clear()
-	c.Handlers.Send.PushBack(func(r *request.Request) {
-		r.HTTPResponse = &http.Response{
-			StatusCode: int(0),
-			Status:     http.StatusText(int(0)),
-			Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
-		}
-		r.Error = awserr.New("RequestError", "send request failed", nil)
-		r.Retryable = aws.Bool(true) // network errors are retryable
-	})
-
-	available := c.Available()
-
-	assert.False(t, available)
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request/handlers_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request/handlers_test.go
@@ -1,47 +0,0 @@
-package request_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-func TestHandlerList(t *testing.T) {
-	s := ""
-	r := &request.Request{}
-	l := request.HandlerList{}
-	l.PushBack(func(r *request.Request) {
-		s += "a"
-		r.Data = s
-	})
-	l.Run(r)
-	assert.Equal(t, "a", s)
-	assert.Equal(t, "a", r.Data)
-}
-
-func TestMultipleHandlers(t *testing.T) {
-	r := &request.Request{}
-	l := request.HandlerList{}
-	l.PushBack(func(r *request.Request) { r.Data = nil })
-	l.PushFront(func(r *request.Request) { r.Data = aws.Bool(true) })
-	l.Run(r)
-	if r.Data != nil {
-		t.Error("Expected handler to execute")
-	}
-}
-
-func TestNamedHandlers(t *testing.T) {
-	l := request.HandlerList{}
-	named := request.NamedHandler{Name: "Name", Fn: func(r *request.Request) {}}
-	named2 := request.NamedHandler{Name: "NotName", Fn: func(r *request.Request) {}}
-	l.PushBackNamed(named)
-	l.PushBackNamed(named)
-	l.PushBackNamed(named2)
-	l.PushBack(func(r *request.Request) {})
-	assert.Equal(t, 4, l.Len())
-	l.Remove(named)
-	assert.Equal(t, 2, l.Len())
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request/request_pagination_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request/request_pagination_test.go
@@ -1,455 +0,0 @@
-package request_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting/unit"
-	"github.com/aws/aws-sdk-go/service/dynamodb"
-	"github.com/aws/aws-sdk-go/service/route53"
-	"github.com/aws/aws-sdk-go/service/s3"
-)
-
-// Use DynamoDB methods for simplicity
-func TestPaginationQueryPage(t *testing.T) {
-	db := dynamodb.New(unit.Session)
-	tokens, pages, numPages, gotToEnd := []map[string]*dynamodb.AttributeValue{}, []map[string]*dynamodb.AttributeValue{}, 0, false
-
-	reqNum := 0
-	resps := []*dynamodb.QueryOutput{
-		{
-			LastEvaluatedKey: map[string]*dynamodb.AttributeValue{"key": {S: aws.String("key1")}},
-			Count:            aws.Int64(1),
-			Items: []map[string]*dynamodb.AttributeValue{
-				map[string]*dynamodb.AttributeValue{
-					"key": {S: aws.String("key1")},
-				},
-			},
-		},
-		{
-			LastEvaluatedKey: map[string]*dynamodb.AttributeValue{"key": {S: aws.String("key2")}},
-			Count:            aws.Int64(1),
-			Items: []map[string]*dynamodb.AttributeValue{
-				map[string]*dynamodb.AttributeValue{
-					"key": {S: aws.String("key2")},
-				},
-			},
-		},
-		{
-			LastEvaluatedKey: map[string]*dynamodb.AttributeValue{},
-			Count:            aws.Int64(1),
-			Items: []map[string]*dynamodb.AttributeValue{
-				map[string]*dynamodb.AttributeValue{
-					"key": {S: aws.String("key3")},
-				},
-			},
-		},
-	}
-
-	db.Handlers.Send.Clear() // mock sending
-	db.Handlers.Unmarshal.Clear()
-	db.Handlers.UnmarshalMeta.Clear()
-	db.Handlers.ValidateResponse.Clear()
-	db.Handlers.Build.PushBack(func(r *request.Request) {
-		in := r.Params.(*dynamodb.QueryInput)
-		if in == nil {
-			tokens = append(tokens, nil)
-		} else if len(in.ExclusiveStartKey) != 0 {
-			tokens = append(tokens, in.ExclusiveStartKey)
-		}
-	})
-	db.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	params := &dynamodb.QueryInput{
-		Limit:     aws.Int64(2),
-		TableName: aws.String("tablename"),
-	}
-	err := db.QueryPages(params, func(p *dynamodb.QueryOutput, last bool) bool {
-		numPages++
-		for _, item := range p.Items {
-			pages = append(pages, item)
-		}
-		if last {
-			if gotToEnd {
-				assert.Fail(t, "last=true happened twice")
-			}
-			gotToEnd = true
-		}
-		return true
-	})
-	assert.Nil(t, err)
-
-	assert.Equal(t,
-		[]map[string]*dynamodb.AttributeValue{
-			map[string]*dynamodb.AttributeValue{"key": {S: aws.String("key1")}},
-			map[string]*dynamodb.AttributeValue{"key": {S: aws.String("key2")}},
-		}, tokens)
-	assert.Equal(t,
-		[]map[string]*dynamodb.AttributeValue{
-			map[string]*dynamodb.AttributeValue{"key": {S: aws.String("key1")}},
-			map[string]*dynamodb.AttributeValue{"key": {S: aws.String("key2")}},
-			map[string]*dynamodb.AttributeValue{"key": {S: aws.String("key3")}},
-		}, pages)
-	assert.Equal(t, 3, numPages)
-	assert.True(t, gotToEnd)
-	assert.Nil(t, params.ExclusiveStartKey)
-}
-
-// Use DynamoDB methods for simplicity
-func TestPagination(t *testing.T) {
-	db := dynamodb.New(unit.Session)
-	tokens, pages, numPages, gotToEnd := []string{}, []string{}, 0, false
-
-	reqNum := 0
-	resps := []*dynamodb.ListTablesOutput{
-		{TableNames: []*string{aws.String("Table1"), aws.String("Table2")}, LastEvaluatedTableName: aws.String("Table2")},
-		{TableNames: []*string{aws.String("Table3"), aws.String("Table4")}, LastEvaluatedTableName: aws.String("Table4")},
-		{TableNames: []*string{aws.String("Table5")}},
-	}
-
-	db.Handlers.Send.Clear() // mock sending
-	db.Handlers.Unmarshal.Clear()
-	db.Handlers.UnmarshalMeta.Clear()
-	db.Handlers.ValidateResponse.Clear()
-	db.Handlers.Build.PushBack(func(r *request.Request) {
-		in := r.Params.(*dynamodb.ListTablesInput)
-		if in == nil {
-			tokens = append(tokens, "")
-		} else if in.ExclusiveStartTableName != nil {
-			tokens = append(tokens, *in.ExclusiveStartTableName)
-		}
-	})
-	db.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	params := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	err := db.ListTablesPages(params, func(p *dynamodb.ListTablesOutput, last bool) bool {
-		numPages++
-		for _, t := range p.TableNames {
-			pages = append(pages, *t)
-		}
-		if last {
-			if gotToEnd {
-				assert.Fail(t, "last=true happened twice")
-			}
-			gotToEnd = true
-		}
-		return true
-	})
-
-	assert.Equal(t, []string{"Table2", "Table4"}, tokens)
-	assert.Equal(t, []string{"Table1", "Table2", "Table3", "Table4", "Table5"}, pages)
-	assert.Equal(t, 3, numPages)
-	assert.True(t, gotToEnd)
-	assert.Nil(t, err)
-	assert.Nil(t, params.ExclusiveStartTableName)
-}
-
-// Use DynamoDB methods for simplicity
-func TestPaginationEachPage(t *testing.T) {
-	db := dynamodb.New(unit.Session)
-	tokens, pages, numPages, gotToEnd := []string{}, []string{}, 0, false
-
-	reqNum := 0
-	resps := []*dynamodb.ListTablesOutput{
-		{TableNames: []*string{aws.String("Table1"), aws.String("Table2")}, LastEvaluatedTableName: aws.String("Table2")},
-		{TableNames: []*string{aws.String("Table3"), aws.String("Table4")}, LastEvaluatedTableName: aws.String("Table4")},
-		{TableNames: []*string{aws.String("Table5")}},
-	}
-
-	db.Handlers.Send.Clear() // mock sending
-	db.Handlers.Unmarshal.Clear()
-	db.Handlers.UnmarshalMeta.Clear()
-	db.Handlers.ValidateResponse.Clear()
-	db.Handlers.Build.PushBack(func(r *request.Request) {
-		in := r.Params.(*dynamodb.ListTablesInput)
-		if in == nil {
-			tokens = append(tokens, "")
-		} else if in.ExclusiveStartTableName != nil {
-			tokens = append(tokens, *in.ExclusiveStartTableName)
-		}
-	})
-	db.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	params := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	req, _ := db.ListTablesRequest(params)
-	err := req.EachPage(func(p interface{}, last bool) bool {
-		numPages++
-		for _, t := range p.(*dynamodb.ListTablesOutput).TableNames {
-			pages = append(pages, *t)
-		}
-		if last {
-			if gotToEnd {
-				assert.Fail(t, "last=true happened twice")
-			}
-			gotToEnd = true
-		}
-
-		return true
-	})
-
-	assert.Equal(t, []string{"Table2", "Table4"}, tokens)
-	assert.Equal(t, []string{"Table1", "Table2", "Table3", "Table4", "Table5"}, pages)
-	assert.Equal(t, 3, numPages)
-	assert.True(t, gotToEnd)
-	assert.Nil(t, err)
-}
-
-// Use DynamoDB methods for simplicity
-func TestPaginationEarlyExit(t *testing.T) {
-	db := dynamodb.New(unit.Session)
-	numPages, gotToEnd := 0, false
-
-	reqNum := 0
-	resps := []*dynamodb.ListTablesOutput{
-		{TableNames: []*string{aws.String("Table1"), aws.String("Table2")}, LastEvaluatedTableName: aws.String("Table2")},
-		{TableNames: []*string{aws.String("Table3"), aws.String("Table4")}, LastEvaluatedTableName: aws.String("Table4")},
-		{TableNames: []*string{aws.String("Table5")}},
-	}
-
-	db.Handlers.Send.Clear() // mock sending
-	db.Handlers.Unmarshal.Clear()
-	db.Handlers.UnmarshalMeta.Clear()
-	db.Handlers.ValidateResponse.Clear()
-	db.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	params := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	err := db.ListTablesPages(params, func(p *dynamodb.ListTablesOutput, last bool) bool {
-		numPages++
-		if numPages == 2 {
-			return false
-		}
-		if last {
-			if gotToEnd {
-				assert.Fail(t, "last=true happened twice")
-			}
-			gotToEnd = true
-		}
-		return true
-	})
-
-	assert.Equal(t, 2, numPages)
-	assert.False(t, gotToEnd)
-	assert.Nil(t, err)
-}
-
-func TestSkipPagination(t *testing.T) {
-	client := s3.New(unit.Session)
-	client.Handlers.Send.Clear() // mock sending
-	client.Handlers.Unmarshal.Clear()
-	client.Handlers.UnmarshalMeta.Clear()
-	client.Handlers.ValidateResponse.Clear()
-	client.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		r.Data = &s3.HeadBucketOutput{}
-	})
-
-	req, _ := client.HeadBucketRequest(&s3.HeadBucketInput{Bucket: aws.String("bucket")})
-
-	numPages, gotToEnd := 0, false
-	req.EachPage(func(p interface{}, last bool) bool {
-		numPages++
-		if last {
-			gotToEnd = true
-		}
-		return true
-	})
-	assert.Equal(t, 1, numPages)
-	assert.True(t, gotToEnd)
-}
-
-// Use S3 for simplicity
-func TestPaginationTruncation(t *testing.T) {
-	client := s3.New(unit.Session)
-
-	reqNum := 0
-	resps := []*s3.ListObjectsOutput{
-		{IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key1")}}},
-		{IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key2")}}},
-		{IsTruncated: aws.Bool(false), Contents: []*s3.Object{{Key: aws.String("Key3")}}},
-		{IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key4")}}},
-	}
-
-	client.Handlers.Send.Clear() // mock sending
-	client.Handlers.Unmarshal.Clear()
-	client.Handlers.UnmarshalMeta.Clear()
-	client.Handlers.ValidateResponse.Clear()
-	client.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	params := &s3.ListObjectsInput{Bucket: aws.String("bucket")}
-
-	results := []string{}
-	err := client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool {
-		results = append(results, *p.Contents[0].Key)
-		return true
-	})
-
-	assert.Equal(t, []string{"Key1", "Key2", "Key3"}, results)
-	assert.Nil(t, err)
-
-	// Try again without truncation token at all
-	reqNum = 0
-	resps[1].IsTruncated = nil
-	resps[2].IsTruncated = aws.Bool(true)
-	results = []string{}
-	err = client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool {
-		results = append(results, *p.Contents[0].Key)
-		return true
-	})
-
-	assert.Equal(t, []string{"Key1", "Key2"}, results)
-	assert.Nil(t, err)
-}
-
-func TestPaginationNilToken(t *testing.T) {
-	client := route53.New(unit.Session)
-
-	reqNum := 0
-	resps := []*route53.ListResourceRecordSetsOutput{
-		{
-			ResourceRecordSets: []*route53.ResourceRecordSet{
-				{Name: aws.String("first.example.com.")},
-			},
-			IsTruncated:          aws.Bool(true),
-			NextRecordName:       aws.String("second.example.com."),
-			NextRecordType:       aws.String("MX"),
-			NextRecordIdentifier: aws.String("second"),
-			MaxItems:             aws.String("1"),
-		},
-		{
-			ResourceRecordSets: []*route53.ResourceRecordSet{
-				{Name: aws.String("second.example.com.")},
-			},
-			IsTruncated:    aws.Bool(true),
-			NextRecordName: aws.String("third.example.com."),
-			NextRecordType: aws.String("MX"),
-			MaxItems:       aws.String("1"),
-		},
-		{
-			ResourceRecordSets: []*route53.ResourceRecordSet{
-				{Name: aws.String("third.example.com.")},
-			},
-			IsTruncated: aws.Bool(false),
-			MaxItems:    aws.String("1"),
-		},
-	}
-	client.Handlers.Send.Clear() // mock sending
-	client.Handlers.Unmarshal.Clear()
-	client.Handlers.UnmarshalMeta.Clear()
-	client.Handlers.ValidateResponse.Clear()
-
-	idents := []string{}
-	client.Handlers.Build.PushBack(func(r *request.Request) {
-		p := r.Params.(*route53.ListResourceRecordSetsInput)
-		idents = append(idents, aws.StringValue(p.StartRecordIdentifier))
-
-	})
-	client.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	params := &route53.ListResourceRecordSetsInput{
-		HostedZoneId: aws.String("id-zone"),
-	}
-
-	results := []string{}
-	err := client.ListResourceRecordSetsPages(params, func(p *route53.ListResourceRecordSetsOutput, last bool) bool {
-		results = append(results, *p.ResourceRecordSets[0].Name)
-		return true
-	})
-
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"", "second", ""}, idents)
-	assert.Equal(t, []string{"first.example.com.", "second.example.com.", "third.example.com."}, results)
-}
-
-// Benchmarks
-var benchResps = []*dynamodb.ListTablesOutput{
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE")}},
-}
-
-var benchDb = func() *dynamodb.DynamoDB {
-	db := dynamodb.New(unit.Session)
-	db.Handlers.Send.Clear() // mock sending
-	db.Handlers.Unmarshal.Clear()
-	db.Handlers.UnmarshalMeta.Clear()
-	db.Handlers.ValidateResponse.Clear()
-	return db
-}
-
-func BenchmarkCodegenIterator(b *testing.B) {
-	reqNum := 0
-	db := benchDb()
-	db.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		r.Data = benchResps[reqNum]
-		reqNum++
-	})
-
-	input := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	iter := func(fn func(*dynamodb.ListTablesOutput, bool) bool) error {
-		page, _ := db.ListTablesRequest(input)
-		for ; page != nil; page = page.NextPage() {
-			page.Send()
-			out := page.Data.(*dynamodb.ListTablesOutput)
-			if result := fn(out, !page.HasNextPage()); page.Error != nil || !result {
-				return page.Error
-			}
-		}
-		return nil
-	}
-
-	for i := 0; i < b.N; i++ {
-		reqNum = 0
-		iter(func(p *dynamodb.ListTablesOutput, last bool) bool {
-			return true
-		})
-	}
-}
-
-func BenchmarkEachPageIterator(b *testing.B) {
-	reqNum := 0
-	db := benchDb()
-	db.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		r.Data = benchResps[reqNum]
-		reqNum++
-	})
-
-	input := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	for i := 0; i < b.N; i++ {
-		reqNum = 0
-		req, _ := db.ListTablesRequest(input)
-		req.EachPage(func(p interface{}, last bool) bool {
-			return true
-		})
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request/request_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request/request_test.go
@@ -1,261 +0,0 @@
-package request_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"runtime"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-)
-
-type testData struct {
-	Data string
-}
-
-func body(str string) io.ReadCloser {
-	return ioutil.NopCloser(bytes.NewReader([]byte(str)))
-}
-
-func unmarshal(req *request.Request) {
-	defer req.HTTPResponse.Body.Close()
-	if req.Data != nil {
-		json.NewDecoder(req.HTTPResponse.Body).Decode(req.Data)
-	}
-	return
-}
-
-func unmarshalError(req *request.Request) {
-	bodyBytes, err := ioutil.ReadAll(req.HTTPResponse.Body)
-	if err != nil {
-		req.Error = awserr.New("UnmarshaleError", req.HTTPResponse.Status, err)
-		return
-	}
-	if len(bodyBytes) == 0 {
-		req.Error = awserr.NewRequestFailure(
-			awserr.New("UnmarshaleError", req.HTTPResponse.Status, fmt.Errorf("empty body")),
-			req.HTTPResponse.StatusCode,
-			"",
-		)
-		return
-	}
-	var jsonErr jsonErrorResponse
-	if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil {
-		req.Error = awserr.New("UnmarshaleError", "JSON unmarshal", err)
-		return
-	}
-	req.Error = awserr.NewRequestFailure(
-		awserr.New(jsonErr.Code, jsonErr.Message, nil),
-		req.HTTPResponse.StatusCode,
-		"",
-	)
-}
-
-type jsonErrorResponse struct {
-	Code    string `json:"__type"`
-	Message string `json:"message"`
-}
-
-// test that retries occur for 5xx status codes
-func TestRequestRecoverRetry5xx(t *testing.T) {
-	reqNum := 0
-	reqs := []http.Response{
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 501, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 200, Body: body(`{"data":"valid"}`)},
-	}
-
-	s := awstesting.NewClient(aws.NewConfig().WithMaxRetries(10))
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *request.Request) {
-		r.HTTPResponse = &reqs[reqNum]
-		reqNum++
-	})
-	out := &testData{}
-	r := s.NewRequest(&request.Operation{Name: "Operation"}, nil, out)
-	err := r.Send()
-	assert.Nil(t, err)
-	assert.Equal(t, 2, int(r.RetryCount))
-	assert.Equal(t, "valid", out.Data)
-}
-
-// test that retries occur for 4xx status codes with a response type that can be retried - see `shouldRetry`
-func TestRequestRecoverRetry4xxRetryable(t *testing.T) {
-	reqNum := 0
-	reqs := []http.Response{
-		{StatusCode: 400, Body: body(`{"__type":"Throttling","message":"Rate exceeded."}`)},
-		{StatusCode: 429, Body: body(`{"__type":"ProvisionedThroughputExceededException","message":"Rate exceeded."}`)},
-		{StatusCode: 200, Body: body(`{"data":"valid"}`)},
-	}
-
-	s := awstesting.NewClient(aws.NewConfig().WithMaxRetries(10))
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *request.Request) {
-		r.HTTPResponse = &reqs[reqNum]
-		reqNum++
-	})
-	out := &testData{}
-	r := s.NewRequest(&request.Operation{Name: "Operation"}, nil, out)
-	err := r.Send()
-	assert.Nil(t, err)
-	assert.Equal(t, 2, int(r.RetryCount))
-	assert.Equal(t, "valid", out.Data)
-}
-
-// test that retries don't occur for 4xx status codes with a response type that can't be retried
-func TestRequest4xxUnretryable(t *testing.T) {
-	s := awstesting.NewClient(aws.NewConfig().WithMaxRetries(10))
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *request.Request) {
-		r.HTTPResponse = &http.Response{StatusCode: 401, Body: body(`{"__type":"SignatureDoesNotMatch","message":"Signature does not match."}`)}
-	})
-	out := &testData{}
-	r := s.NewRequest(&request.Operation{Name: "Operation"}, nil, out)
-	err := r.Send()
-	assert.NotNil(t, err)
-	if e, ok := err.(awserr.RequestFailure); ok {
-		assert.Equal(t, 401, e.StatusCode())
-	} else {
-		assert.Fail(t, "Expected error to be a service failure")
-	}
-	assert.Equal(t, "SignatureDoesNotMatch", err.(awserr.Error).Code())
-	assert.Equal(t, "Signature does not match.", err.(awserr.Error).Message())
-	assert.Equal(t, 0, int(r.RetryCount))
-}
-
-func TestRequestExhaustRetries(t *testing.T) {
-	delays := []time.Duration{}
-	sleepDelay := func(delay time.Duration) {
-		delays = append(delays, delay)
-	}
-
-	reqNum := 0
-	reqs := []http.Response{
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-	}
-
-	s := awstesting.NewClient(aws.NewConfig().WithSleepDelay(sleepDelay))
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *request.Request) {
-		r.HTTPResponse = &reqs[reqNum]
-		reqNum++
-	})
-	r := s.NewRequest(&request.Operation{Name: "Operation"}, nil, nil)
-	err := r.Send()
-	assert.NotNil(t, err)
-	if e, ok := err.(awserr.RequestFailure); ok {
-		assert.Equal(t, 500, e.StatusCode())
-	} else {
-		assert.Fail(t, "Expected error to be a service failure")
-	}
-	assert.Equal(t, "UnknownError", err.(awserr.Error).Code())
-	assert.Equal(t, "An error occurred.", err.(awserr.Error).Message())
-	assert.Equal(t, 3, int(r.RetryCount))
-
-	expectDelays := []struct{ min, max time.Duration }{{30, 59}, {60, 118}, {120, 236}}
-	for i, v := range delays {
-		min := expectDelays[i].min * time.Millisecond
-		max := expectDelays[i].max * time.Millisecond
-		assert.True(t, min <= v && v <= max,
-			"Expect delay to be within range, i:%d, v:%s, min:%s, max:%s", i, v, min, max)
-	}
-}
-
-// test that the request is retried after the credentials are expired.
-func TestRequestRecoverExpiredCreds(t *testing.T) {
-	reqNum := 0
-	reqs := []http.Response{
-		{StatusCode: 400, Body: body(`{"__type":"ExpiredTokenException","message":"expired token"}`)},
-		{StatusCode: 200, Body: body(`{"data":"valid"}`)},
-	}
-
-	s := awstesting.NewClient(&aws.Config{MaxRetries: aws.Int(10), Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "")})
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-
-	credExpiredBeforeRetry := false
-	credExpiredAfterRetry := false
-
-	s.Handlers.AfterRetry.PushBack(func(r *request.Request) {
-		credExpiredAfterRetry = r.Config.Credentials.IsExpired()
-	})
-
-	s.Handlers.Sign.Clear()
-	s.Handlers.Sign.PushBack(func(r *request.Request) {
-		r.Config.Credentials.Get()
-	})
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *request.Request) {
-		r.HTTPResponse = &reqs[reqNum]
-		reqNum++
-	})
-	out := &testData{}
-	r := s.NewRequest(&request.Operation{Name: "Operation"}, nil, out)
-	err := r.Send()
-	assert.Nil(t, err)
-
-	assert.False(t, credExpiredBeforeRetry, "Expect valid creds before retry check")
-	assert.True(t, credExpiredAfterRetry, "Expect expired creds after retry check")
-	assert.False(t, s.Config.Credentials.IsExpired(), "Expect valid creds after cred expired recovery")
-
-	assert.Equal(t, 1, int(r.RetryCount))
-	assert.Equal(t, "valid", out.Data)
-}
-
-func TestMakeAddtoUserAgentHandler(t *testing.T) {
-	fn := request.MakeAddToUserAgentHandler("name", "version", "extra1", "extra2")
-	r := &request.Request{HTTPRequest: &http.Request{Header: http.Header{}}}
-	r.HTTPRequest.Header.Set("User-Agent", "foo/bar")
-	fn(r)
-
-	assert.Equal(t, "foo/bar name/version (extra1; extra2)", r.HTTPRequest.Header.Get("User-Agent"))
-}
-
-func TestMakeAddtoUserAgentFreeFormHandler(t *testing.T) {
-	fn := request.MakeAddToUserAgentFreeFormHandler("name/version (extra1; extra2)")
-	r := &request.Request{HTTPRequest: &http.Request{Header: http.Header{}}}
-	r.HTTPRequest.Header.Set("User-Agent", "foo/bar")
-	fn(r)
-
-	assert.Equal(t, "foo/bar name/version (extra1; extra2)", r.HTTPRequest.Header.Get("User-Agent"))
-}
-
-func TestRequestUserAgent(t *testing.T) {
-	s := awstesting.NewClient(&aws.Config{Region: aws.String("us-east-1")})
-	//	s.Handlers.Validate.Clear()
-
-	req := s.NewRequest(&request.Operation{Name: "Operation"}, nil, &testData{})
-	req.HTTPRequest.Header.Set("User-Agent", "foo/bar")
-	assert.NoError(t, req.Build())
-
-	expectUA := fmt.Sprintf("foo/bar %s/%s (%s; %s; %s)",
-		aws.SDKName, aws.SDKVersion, runtime.Version(), runtime.GOOS, runtime.GOARCH)
-	assert.Equal(t, expectUA, req.HTTPRequest.Header.Get("User-Agent"))
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/session/session.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/session/session.go
@@ -1,105 +0,0 @@
-// Package session provides a way to create service clients with shared configuration
-// and handlers.
-package session
-
-import (
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/aws/corehandlers"
-	"github.com/aws/aws-sdk-go/aws/defaults"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/endpoints"
-)
-
-// A Session provides a central location to create service clients from and
-// store configurations and request handlers for those services.
-//
-// Sessions are safe to create service clients concurrently, but it is not safe
-// to mutate the session concurrently.
-type Session struct {
-	Config   *aws.Config
-	Handlers request.Handlers
-}
-
-// New creates a new instance of the handlers merging in the provided Configs
-// on top of the SDK's default configurations. Once the session is created it
-// can be mutated to modify Configs or Handlers. The session is safe to be read
-// concurrently, but it should not be written to concurrently.
-//
-// Example:
-//     // Create a session with the default config and request handlers.
-//     sess := session.New()
-//
-//     // Create a session with a custom region
-//     sess := session.New(&aws.Config{Region: aws.String("us-east-1")})
-//
-//     // Create a session, and add additional handlers for all service
-//     // clients created with the session to inherit. Adds logging handler.
-//     sess := session.New()
-//     sess.Handlers.Send.PushFront(func(r *request.Request) {
-//          // Log every request made and its payload
-//          logger.Println("Request: %s/%s, Payload: %s", r.ClientInfo.ServiceName, r.Operation, r.Params)
-//     })
-//
-//     // Create a S3 client instance from a session
-//     sess := session.New()
-//     svc := s3.New(sess)
-func New(cfgs ...*aws.Config) *Session {
-	def := defaults.Get()
-	s := &Session{
-		Config:   def.Config,
-		Handlers: def.Handlers,
-	}
-	s.Config.MergeIn(cfgs...)
-
-	initHandlers(s)
-
-	return s
-}
-
-func initHandlers(s *Session) {
-	// Add the Validate parameter handler if it is not disabled.
-	s.Handlers.Validate.Remove(corehandlers.ValidateParametersHandler)
-	if !aws.BoolValue(s.Config.DisableParamValidation) {
-		s.Handlers.Validate.PushBackNamed(corehandlers.ValidateParametersHandler)
-	}
-}
-
-// Copy creates and returns a copy of the current session, coping the config
-// and handlers. If any additional configs are provided they will be merged
-// on top of the session's copied config.
-//
-// Example:
-//     // Create a copy of the current session, configured for the us-west-2 region.
-//     sess.Copy(&aws.Config{Region: aws.String("us-west-2"})
-func (s *Session) Copy(cfgs ...*aws.Config) *Session {
-	newSession := &Session{
-		Config:   s.Config.Copy(cfgs...),
-		Handlers: s.Handlers.Copy(),
-	}
-
-	initHandlers(newSession)
-
-	return newSession
-}
-
-// ClientConfig satisfies the client.ConfigProvider interface and is used to
-// configure the service client instances. Passing the Session to the service
-// client's constructor (New) will use this method to configure the client.
-//
-// Example:
-//     sess := session.New()
-//     s3.New(sess)
-func (s *Session) ClientConfig(serviceName string, cfgs ...*aws.Config) client.Config {
-	s = s.Copy(cfgs...)
-	endpoint, signingRegion := endpoints.NormalizeEndpoint(
-		aws.StringValue(s.Config.Endpoint), serviceName,
-		aws.StringValue(s.Config.Region), aws.BoolValue(s.Config.DisableSSL))
-
-	return client.Config{
-		Config:        s.Config,
-		Handlers:      s.Handlers,
-		Endpoint:      endpoint,
-		SigningRegion: signingRegion,
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/session/session_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/session/session_test.go
@@ -1,20 +0,0 @@
-package session_test
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-)
-
-func TestNewDefaultSession(t *testing.T) {
-	s := session.New(&aws.Config{Region: aws.String("region")})
-
-	assert.Equal(t, "region", *s.Config.Region)
-	assert.Equal(t, http.DefaultClient, s.Config.HTTPClient)
-	assert.NotNil(t, s.Config.Logger)
-	assert.Equal(t, aws.LogOff, *s.Config.LogLevel)
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/types_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/types_test.go
@@ -1,56 +0,0 @@
-package aws
-
-import (
-	"math/rand"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestWriteAtBuffer(t *testing.T) {
-	b := &WriteAtBuffer{}
-
-	n, err := b.WriteAt([]byte{1}, 0)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, n)
-
-	n, err = b.WriteAt([]byte{1, 1, 1}, 5)
-	assert.NoError(t, err)
-	assert.Equal(t, 3, n)
-
-	n, err = b.WriteAt([]byte{2}, 1)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, n)
-
-	n, err = b.WriteAt([]byte{3}, 2)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, n)
-
-	assert.Equal(t, []byte{1, 2, 3, 0, 0, 1, 1, 1}, b.Bytes())
-}
-
-func BenchmarkWriteAtBuffer(b *testing.B) {
-	buf := &WriteAtBuffer{}
-	r := rand.New(rand.NewSource(1))
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		to := r.Intn(10) * 4096
-		bs := make([]byte, to)
-		buf.WriteAt(bs, r.Int63n(10)*4096)
-	}
-}
-
-func BenchmarkWriteAtBufferParallel(b *testing.B) {
-	buf := &WriteAtBuffer{}
-	r := rand.New(rand.NewSource(1))
-
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			to := r.Intn(10) * 4096
-			bs := make([]byte, to)
-			buf.WriteAt(bs, r.Int63n(10)*4096)
-		}
-	})
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints/endpoints.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints/endpoints.go
@@ -1,31 +0,0 @@
-// Package endpoints validates regional endpoints for services.
-package endpoints
-
-//go:generate go run ../model/cli/gen-endpoints/main.go endpoints.json endpoints_map.go
-//go:generate gofmt -s -w endpoints_map.go
-
-import "strings"
-
-// EndpointForRegion returns an endpoint and its signing region for a service and region.
-// if the service and region pair are not found endpoint and signingRegion will be empty.
-func EndpointForRegion(svcName, region string) (endpoint, signingRegion string) {
-	derivedKeys := []string{
-		region + "/" + svcName,
-		region + "/*",
-		"*/" + svcName,
-		"*/*",
-	}
-
-	for _, key := range derivedKeys {
-		if val, ok := endpointsMap.Endpoints[key]; ok {
-			ep := val.Endpoint
-			ep = strings.Replace(ep, "{region}", region, -1)
-			ep = strings.Replace(ep, "{service}", svcName, -1)
-
-			endpoint = ep
-			signingRegion = val.SigningRegion
-			return
-		}
-	}
-	return
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints/endpoints.json
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints/endpoints.json
@@ -1,77 +0,0 @@
-{
-  "version": 2,
-  "endpoints": {
-    "*/*": {
-      "endpoint": "{service}.{region}.amazonaws.com"
-    },
-    "cn-north-1/*": {
-      "endpoint": "{service}.{region}.amazonaws.com.cn",
-      "signatureVersion": "v4"
-    },
-    "us-gov-west-1/iam": {
-      "endpoint": "iam.us-gov.amazonaws.com"
-    },
-    "us-gov-west-1/sts": {
-      "endpoint": "sts.us-gov-west-1.amazonaws.com"
-    },
-    "us-gov-west-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "*/cloudfront": {
-      "endpoint": "cloudfront.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/cloudsearchdomain": {
-      "endpoint": "",
-      "signingRegion": "us-east-1"
-    },
-    "*/iam": {
-      "endpoint": "iam.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/importexport": {
-      "endpoint": "importexport.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/route53": {
-      "endpoint": "route53.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/sts": {
-      "endpoint": "sts.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "us-east-1/sdb": {
-      "endpoint": "sdb.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "us-east-1/s3": {
-      "endpoint": "s3.amazonaws.com"
-    },
-    "us-west-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "us-west-2/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "eu-west-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "ap-southeast-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "ap-southeast-2/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "ap-northeast-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "sa-east-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "eu-central-1/s3": {
-      "endpoint": "{service}.{region}.amazonaws.com",
-      "signatureVersion": "v4"
-    }
-  }
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints/endpoints_map.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints/endpoints_map.go
@@ -1,89 +0,0 @@
-package endpoints
-
-// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
-
-type endpointStruct struct {
-	Version   int
-	Endpoints map[string]endpointEntry
-}
-
-type endpointEntry struct {
-	Endpoint      string
-	SigningRegion string
-}
-
-var endpointsMap = endpointStruct{
-	Version: 2,
-	Endpoints: map[string]endpointEntry{
-		"*/*": {
-			Endpoint: "{service}.{region}.amazonaws.com",
-		},
-		"*/cloudfront": {
-			Endpoint:      "cloudfront.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/cloudsearchdomain": {
-			Endpoint:      "",
-			SigningRegion: "us-east-1",
-		},
-		"*/iam": {
-			Endpoint:      "iam.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/importexport": {
-			Endpoint:      "importexport.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/route53": {
-			Endpoint:      "route53.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/sts": {
-			Endpoint:      "sts.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"ap-northeast-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"ap-southeast-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"ap-southeast-2/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"cn-north-1/*": {
-			Endpoint: "{service}.{region}.amazonaws.com.cn",
-		},
-		"eu-central-1/s3": {
-			Endpoint: "{service}.{region}.amazonaws.com",
-		},
-		"eu-west-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"sa-east-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"us-east-1/s3": {
-			Endpoint: "s3.amazonaws.com",
-		},
-		"us-east-1/sdb": {
-			Endpoint:      "sdb.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"us-gov-west-1/iam": {
-			Endpoint: "iam.us-gov.amazonaws.com",
-		},
-		"us-gov-west-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"us-gov-west-1/sts": {
-			Endpoint: "sts.us-gov-west-1.amazonaws.com",
-		},
-		"us-west-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"us-west-2/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-	},
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints/endpoints_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints/endpoints_test.go
@@ -1,28 +0,0 @@
-package endpoints
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGlobalEndpoints(t *testing.T) {
-	region := "mock-region-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts"}
-
-	for _, name := range svcs {
-		ep, sr := EndpointForRegion(name, region)
-		assert.Equal(t, name+".amazonaws.com", ep)
-		assert.Equal(t, "us-east-1", sr)
-	}
-}
-
-func TestServicesInCN(t *testing.T) {
-	region := "cn-north-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts", "s3"}
-
-	for _, name := range svcs {
-		ep, _ := EndpointForRegion(name, region)
-		assert.Equal(t, name+"."+region+".amazonaws.com.cn", ep)
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/build.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/build.go
@@ -1,32 +0,0 @@
-// Package ec2query provides serialisation of AWS EC2 requests and responses.
-package ec2query
-
-//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/input/ec2.json build_test.go
-
-import (
-	"net/url"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/internal/protocol/query/queryutil"
-)
-
-// Build builds a request for the EC2 protocol.
-func Build(r *aws.Request) {
-	body := url.Values{
-		"Action":  {r.Operation.Name},
-		"Version": {r.Service.APIVersion},
-	}
-	if err := queryutil.Parse(body, r.Params, true); err != nil {
-		r.Error = awserr.New("SerializationError", "failed encoding EC2 Query request", err)
-	}
-
-	if r.ExpireTime == 0 {
-		r.HTTPRequest.Method = "POST"
-		r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
-		r.SetBufferBody([]byte(body.Encode()))
-	} else { // This is a pre-signed request
-		r.HTTPRequest.Method = "GET"
-		r.HTTPRequest.URL.RawQuery = body.Encode()
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/build_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/build_test.go
@@ -1,860 +0,0 @@
-package ec2query_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"encoding/xml"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-	"github.com/aws/aws-sdk-go/internal/signer/v4"
-	"github.com/aws/aws-sdk-go/internal/util"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ bytes.Buffer // always import bytes
-var _ http.Request
-var _ json.Marshaler
-var _ time.Time
-var _ xmlutil.XMLNode
-var _ xml.Attr
-var _ = ioutil.Discard
-var _ = util.Trim("")
-var _ = url.Values{}
-var _ = io.EOF
-
-type InputService1ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService1ProtocolTest client.
-func NewInputService1ProtocolTest(config *aws.Config) *InputService1ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice1protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService1ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService1ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService1ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService1TestCaseOperation1 = "OperationName"
-
-// InputService1TestCaseOperation1Request generates a request for the InputService1TestCaseOperation1 operation.
-func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputShape) (req *aws.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService1TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService1TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService1TestShapeInputService1TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputShape) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) {
-	req, out := c.InputService1TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService1TestShapeInputService1TestCaseOperation1Output struct {
-	metadataInputService1TestShapeInputService1TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService1TestShapeInputService1TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService1TestShapeInputShape struct {
-	Bar *string `type:"string"`
-
-	Foo *string `type:"string"`
-
-	metadataInputService1TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService1TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService2ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService2ProtocolTest client.
-func NewInputService2ProtocolTest(config *aws.Config) *InputService2ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice2protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService2ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService2ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService2ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService2TestCaseOperation1 = "OperationName"
-
-// InputService2TestCaseOperation1Request generates a request for the InputService2TestCaseOperation1 operation.
-func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputShape) (req *aws.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService2TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService2TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService2TestShapeInputService2TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputShape) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) {
-	req, out := c.InputService2TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService2TestShapeInputService2TestCaseOperation1Output struct {
-	metadataInputService2TestShapeInputService2TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService2TestShapeInputService2TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService2TestShapeInputShape struct {
-	Bar *string `locationName:"barLocationName" type:"string"`
-
-	Foo *string `type:"string"`
-
-	Yuck *string `locationName:"yuckLocationName" queryName:"yuckQueryName" type:"string"`
-
-	metadataInputService2TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService2TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService3ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService3ProtocolTest client.
-func NewInputService3ProtocolTest(config *aws.Config) *InputService3ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice3protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService3ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService3ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService3ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService3TestCaseOperation1 = "OperationName"
-
-// InputService3TestCaseOperation1Request generates a request for the InputService3TestCaseOperation1 operation.
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputShape) (req *aws.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService3TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService3TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService3TestShapeInputService3TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputShape) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
-	req, out := c.InputService3TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService3TestShapeInputService3TestCaseOperation1Output struct {
-	metadataInputService3TestShapeInputService3TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService3TestShapeInputService3TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService3TestShapeInputShape struct {
-	StructArg *InputService3TestShapeStructType `locationName:"Struct" type:"structure"`
-
-	metadataInputService3TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService3TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService3TestShapeStructType struct {
-	ScalarArg *string `locationName:"Scalar" type:"string"`
-
-	metadataInputService3TestShapeStructType `json:"-" xml:"-"`
-}
-
-type metadataInputService3TestShapeStructType struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService4ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService4ProtocolTest client.
-func NewInputService4ProtocolTest(config *aws.Config) *InputService4ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice4protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService4ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService4ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService4ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService4TestCaseOperation1 = "OperationName"
-
-// InputService4TestCaseOperation1Request generates a request for the InputService4TestCaseOperation1 operation.
-func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputShape) (req *aws.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService4TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService4TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService4TestShapeInputService4TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputShape) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) {
-	req, out := c.InputService4TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService4TestShapeInputService4TestCaseOperation1Output struct {
-	metadataInputService4TestShapeInputService4TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService4TestShapeInputService4TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService4TestShapeInputShape struct {
-	ListArg []*string `type:"list"`
-
-	metadataInputService4TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService4TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService5ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService5ProtocolTest client.
-func NewInputService5ProtocolTest(config *aws.Config) *InputService5ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice5protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService5ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService5ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService5ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService5TestCaseOperation1 = "OperationName"
-
-// InputService5TestCaseOperation1Request generates a request for the InputService5TestCaseOperation1 operation.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputShape) (req *aws.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService5TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService5TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService5TestShapeInputService5TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
-	req, out := c.InputService5TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService5TestShapeInputService5TestCaseOperation1Output struct {
-	metadataInputService5TestShapeInputService5TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService5TestShapeInputService5TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService5TestShapeInputShape struct {
-	ListArg []*string `locationName:"ListMemberName" locationNameList:"item" type:"list"`
-
-	metadataInputService5TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService5TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService6ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService6ProtocolTest client.
-func NewInputService6ProtocolTest(config *aws.Config) *InputService6ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice6protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService6ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService6ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService6ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService6TestCaseOperation1 = "OperationName"
-
-// InputService6TestCaseOperation1Request generates a request for the InputService6TestCaseOperation1 operation.
-func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputShape) (req *aws.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService6TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService6TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService6TestShapeInputService6TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputShape) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) {
-	req, out := c.InputService6TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService6TestShapeInputService6TestCaseOperation1Output struct {
-	metadataInputService6TestShapeInputService6TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService6TestShapeInputService6TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService6TestShapeInputShape struct {
-	ListArg []*string `locationName:"ListMemberName" queryName:"ListQueryName" locationNameList:"item" type:"list"`
-
-	metadataInputService6TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService6TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService7ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService7ProtocolTest client.
-func NewInputService7ProtocolTest(config *aws.Config) *InputService7ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice7protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService7ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService7ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService7ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService7TestCaseOperation1 = "OperationName"
-
-// InputService7TestCaseOperation1Request generates a request for the InputService7TestCaseOperation1 operation.
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputShape) (req *aws.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService7TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService7TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService7TestShapeInputService7TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputShape) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
-	req, out := c.InputService7TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService7TestShapeInputService7TestCaseOperation1Output struct {
-	metadataInputService7TestShapeInputService7TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService7TestShapeInputService7TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService7TestShapeInputShape struct {
-	BlobArg []byte `type:"blob"`
-
-	metadataInputService7TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService7TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService8ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService8ProtocolTest client.
-func NewInputService8ProtocolTest(config *aws.Config) *InputService8ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice8protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService8ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService8ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService8ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService8TestCaseOperation1 = "OperationName"
-
-// InputService8TestCaseOperation1Request generates a request for the InputService8TestCaseOperation1 operation.
-func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService8TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService8TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService8TestShapeInputService8TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputShape) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) {
-	req, out := c.InputService8TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService8TestShapeInputService8TestCaseOperation1Output struct {
-	metadataInputService8TestShapeInputService8TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService8TestShapeInputService8TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService8TestShapeInputShape struct {
-	TimeArg *time.Time `type:"timestamp" timestampFormat:"iso8601"`
-
-	metadataInputService8TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService8TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-//
-// Tests begin here
-//
-
-func TestInputService1ProtocolTestScalarMembersCase1(t *testing.T) {
-	svc := NewInputService1ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService1TestShapeInputShape{
-		Bar: aws.String("val2"),
-		Foo: aws.String("val1"),
-	}
-	req, _ := svc.InputService1TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&Bar=val2&Foo=val1&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService2ProtocolTestStructureWithLocationNameAndQueryNameAppliedToMembersCase1(t *testing.T) {
-	svc := NewInputService2ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService2TestShapeInputShape{
-		Bar:  aws.String("val2"),
-		Foo:  aws.String("val1"),
-		Yuck: aws.String("val3"),
-	}
-	req, _ := svc.InputService2TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&BarLocationName=val2&Foo=val1&Version=2014-01-01&yuckQueryName=val3`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService3ProtocolTestNestedStructureMembersCase1(t *testing.T) {
-	svc := NewInputService3ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService3TestShapeInputShape{
-		StructArg: &InputService3TestShapeStructType{
-			ScalarArg: aws.String("foo"),
-		},
-	}
-	req, _ := svc.InputService3TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&Struct.Scalar=foo&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService4ProtocolTestListTypesCase1(t *testing.T) {
-	svc := NewInputService4ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService4TestShapeInputShape{
-		ListArg: []*string{
-			aws.String("foo"),
-			aws.String("bar"),
-			aws.String("baz"),
-		},
-	}
-	req, _ := svc.InputService4TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&ListArg.1=foo&ListArg.2=bar&ListArg.3=baz&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService5ProtocolTestListWithLocationNameAppliedToMemberCase1(t *testing.T) {
-	svc := NewInputService5ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService5TestShapeInputShape{
-		ListArg: []*string{
-			aws.String("a"),
-			aws.String("b"),
-			aws.String("c"),
-		},
-	}
-	req, _ := svc.InputService5TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&ListMemberName.1=a&ListMemberName.2=b&ListMemberName.3=c&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService6ProtocolTestListWithLocationNameAndQueryNameCase1(t *testing.T) {
-	svc := NewInputService6ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService6TestShapeInputShape{
-		ListArg: []*string{
-			aws.String("a"),
-			aws.String("b"),
-			aws.String("c"),
-		},
-	}
-	req, _ := svc.InputService6TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&ListQueryName.1=a&ListQueryName.2=b&ListQueryName.3=c&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService7ProtocolTestBase64EncodedBlobsCase1(t *testing.T) {
-	svc := NewInputService7ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService7TestShapeInputShape{
-		BlobArg: []byte("foo"),
-	}
-	req, _ := svc.InputService7TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&BlobArg=Zm9v&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService8ProtocolTestTimestampValuesCase1(t *testing.T) {
-	svc := NewInputService8ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService8TestShapeInputShape{
-		TimeArg: aws.Time(time.Unix(1422172800, 0)),
-	}
-	req, _ := svc.InputService8TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&TimeArg=2015-01-25T08%3A00%3A00Z&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/unmarshal.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/unmarshal.go
@@ -1,54 +0,0 @@
-package ec2query
-
-//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/output/ec2.json unmarshal_test.go
-
-import (
-	"encoding/xml"
-	"io"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-)
-
-// Unmarshal unmarshals a response body for the EC2 protocol.
-func Unmarshal(r *aws.Request) {
-	defer r.HTTPResponse.Body.Close()
-	if r.DataFilled() {
-		decoder := xml.NewDecoder(r.HTTPResponse.Body)
-		err := xmlutil.UnmarshalXML(r.Data, decoder, "")
-		if err != nil {
-			r.Error = awserr.New("SerializationError", "failed decoding EC2 Query response", err)
-			return
-		}
-	}
-}
-
-// UnmarshalMeta unmarshals response headers for the EC2 protocol.
-func UnmarshalMeta(r *aws.Request) {
-	// TODO implement unmarshaling of request IDs
-}
-
-type xmlErrorResponse struct {
-	XMLName   xml.Name `xml:"Response"`
-	Code      string   `xml:"Errors>Error>Code"`
-	Message   string   `xml:"Errors>Error>Message"`
-	RequestID string   `xml:"RequestId"`
-}
-
-// UnmarshalError unmarshals a response error for the EC2 protocol.
-func UnmarshalError(r *aws.Request) {
-	defer r.HTTPResponse.Body.Close()
-
-	resp := &xmlErrorResponse{}
-	err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
-	if err != nil && err != io.EOF {
-		r.Error = awserr.New("SerializationError", "failed decoding EC2 Query error response", err)
-	} else {
-		r.Error = awserr.NewRequestFailure(
-			awserr.New(resp.Code, resp.Message, nil),
-			r.HTTPResponse.StatusCode,
-			resp.RequestID,
-		)
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/unmarshal_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/unmarshal_test.go
@@ -1,816 +0,0 @@
-package ec2query_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"encoding/xml"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-	"github.com/aws/aws-sdk-go/internal/signer/v4"
-	"github.com/aws/aws-sdk-go/internal/util"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ bytes.Buffer // always import bytes
-var _ http.Request
-var _ json.Marshaler
-var _ time.Time
-var _ xmlutil.XMLNode
-var _ xml.Attr
-var _ = ioutil.Discard
-var _ = util.Trim("")
-var _ = url.Values{}
-var _ = io.EOF
-
-type OutputService1ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService1ProtocolTest client.
-func NewOutputService1ProtocolTest(config *aws.Config) *OutputService1ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice1protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService1ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService1ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService1ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService1TestCaseOperation1 = "OperationName"
-
-// OutputService1TestCaseOperation1Request generates a request for the OutputService1TestCaseOperation1 operation.
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *aws.Request, output *OutputService1TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService1TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService1TestShapeOutputService1TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService1TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (*OutputService1TestShapeOutputShape, error) {
-	req, out := c.OutputService1TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService1TestShapeOutputService1TestCaseOperation1Input struct {
-	metadataOutputService1TestShapeOutputService1TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService1TestShapeOutputService1TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService1TestShapeOutputShape struct {
-	Char *string `type:"character"`
-
-	Double *float64 `type:"double"`
-
-	FalseBool *bool `type:"boolean"`
-
-	Float *float64 `type:"float"`
-
-	Long *int64 `type:"long"`
-
-	Num *int64 `locationName:"FooNum" type:"integer"`
-
-	Str *string `type:"string"`
-
-	TrueBool *bool `type:"boolean"`
-
-	metadataOutputService1TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService1TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService2ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService2ProtocolTest client.
-func NewOutputService2ProtocolTest(config *aws.Config) *OutputService2ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice2protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService2ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService2ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService2ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService2TestCaseOperation1 = "OperationName"
-
-// OutputService2TestCaseOperation1Request generates a request for the OutputService2TestCaseOperation1 operation.
-func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (req *aws.Request, output *OutputService2TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService2TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService2TestShapeOutputService2TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService2TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (*OutputService2TestShapeOutputShape, error) {
-	req, out := c.OutputService2TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService2TestShapeOutputService2TestCaseOperation1Input struct {
-	metadataOutputService2TestShapeOutputService2TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService2TestShapeOutputService2TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService2TestShapeOutputShape struct {
-	Blob []byte `type:"blob"`
-
-	metadataOutputService2TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService2TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService3ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService3ProtocolTest client.
-func NewOutputService3ProtocolTest(config *aws.Config) *OutputService3ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice3protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService3ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService3ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService3ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService3TestCaseOperation1 = "OperationName"
-
-// OutputService3TestCaseOperation1Request generates a request for the OutputService3TestCaseOperation1 operation.
-func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (req *aws.Request, output *OutputService3TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService3TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService3TestShapeOutputService3TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService3TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (*OutputService3TestShapeOutputShape, error) {
-	req, out := c.OutputService3TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService3TestShapeOutputService3TestCaseOperation1Input struct {
-	metadataOutputService3TestShapeOutputService3TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService3TestShapeOutputService3TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService3TestShapeOutputShape struct {
-	ListMember []*string `type:"list"`
-
-	metadataOutputService3TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService3TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService4ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService4ProtocolTest client.
-func NewOutputService4ProtocolTest(config *aws.Config) *OutputService4ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice4protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService4ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService4ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService4ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService4TestCaseOperation1 = "OperationName"
-
-// OutputService4TestCaseOperation1Request generates a request for the OutputService4TestCaseOperation1 operation.
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *aws.Request, output *OutputService4TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService4TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService4TestShapeOutputService4TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService4TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (*OutputService4TestShapeOutputShape, error) {
-	req, out := c.OutputService4TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService4TestShapeOutputService4TestCaseOperation1Input struct {
-	metadataOutputService4TestShapeOutputService4TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService4TestShapeOutputService4TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService4TestShapeOutputShape struct {
-	ListMember []*string `locationNameList:"item" type:"list"`
-
-	metadataOutputService4TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService4TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService5ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService5ProtocolTest client.
-func NewOutputService5ProtocolTest(config *aws.Config) *OutputService5ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice5protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService5ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService5ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService5ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService5TestCaseOperation1 = "OperationName"
-
-// OutputService5TestCaseOperation1Request generates a request for the OutputService5TestCaseOperation1 operation.
-func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (req *aws.Request, output *OutputService5TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService5TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService5TestShapeOutputService5TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService5TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (*OutputService5TestShapeOutputShape, error) {
-	req, out := c.OutputService5TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService5TestShapeOutputService5TestCaseOperation1Input struct {
-	metadataOutputService5TestShapeOutputService5TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService5TestShapeOutputService5TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService5TestShapeOutputShape struct {
-	ListMember []*string `type:"list" flattened:"true"`
-
-	metadataOutputService5TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService5TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService6ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService6ProtocolTest client.
-func NewOutputService6ProtocolTest(config *aws.Config) *OutputService6ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice6protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService6ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService6ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService6ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService6TestCaseOperation1 = "OperationName"
-
-// OutputService6TestCaseOperation1Request generates a request for the OutputService6TestCaseOperation1 operation.
-func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (req *aws.Request, output *OutputService6TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService6TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService6TestShapeOutputService6TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService6TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (*OutputService6TestShapeOutputShape, error) {
-	req, out := c.OutputService6TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService6TestShapeOutputService6TestCaseOperation1Input struct {
-	metadataOutputService6TestShapeOutputService6TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService6TestShapeOutputService6TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService6TestShapeOutputShape struct {
-	Map map[string]*OutputService6TestShapeStructureType `type:"map"`
-
-	metadataOutputService6TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService6TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService6TestShapeStructureType struct {
-	Foo *string `locationName:"foo" type:"string"`
-
-	metadataOutputService6TestShapeStructureType `json:"-" xml:"-"`
-}
-
-type metadataOutputService6TestShapeStructureType struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService7ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService7ProtocolTest client.
-func NewOutputService7ProtocolTest(config *aws.Config) *OutputService7ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice7protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService7ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService7ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService7ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService7TestCaseOperation1 = "OperationName"
-
-// OutputService7TestCaseOperation1Request generates a request for the OutputService7TestCaseOperation1 operation.
-func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (req *aws.Request, output *OutputService7TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService7TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService7TestShapeOutputService7TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService7TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (*OutputService7TestShapeOutputShape, error) {
-	req, out := c.OutputService7TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService7TestShapeOutputService7TestCaseOperation1Input struct {
-	metadataOutputService7TestShapeOutputService7TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService7TestShapeOutputService7TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService7TestShapeOutputShape struct {
-	Map map[string]*string `type:"map" flattened:"true"`
-
-	metadataOutputService7TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService7TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService8ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService8ProtocolTest client.
-func NewOutputService8ProtocolTest(config *aws.Config) *OutputService8ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice8protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService8ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService8ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService8ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService8TestCaseOperation1 = "OperationName"
-
-// OutputService8TestCaseOperation1Request generates a request for the OutputService8TestCaseOperation1 operation.
-func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (req *aws.Request, output *OutputService8TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService8TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService8TestShapeOutputService8TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService8TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (*OutputService8TestShapeOutputShape, error) {
-	req, out := c.OutputService8TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService8TestShapeOutputService8TestCaseOperation1Input struct {
-	metadataOutputService8TestShapeOutputService8TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService8TestShapeOutputService8TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService8TestShapeOutputShape struct {
-	Map map[string]*string `locationNameKey:"foo" locationNameValue:"bar" type:"map" flattened:"true"`
-
-	metadataOutputService8TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService8TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-//
-// Tests begin here
-//
-
-func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) {
-	svc := NewOutputService1ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Str>myname</Str><FooNum>123</FooNum><FalseBool>false</FalseBool><TrueBool>true</TrueBool><Float>1.2</Float><Double>1.3</Double><Long>200</Long><Char>a</Char><RequestId>request-id</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService1TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "a", *out.Char)
-	assert.Equal(t, 1.3, *out.Double)
-	assert.Equal(t, false, *out.FalseBool)
-	assert.Equal(t, 1.2, *out.Float)
-	assert.Equal(t, int64(200), *out.Long)
-	assert.Equal(t, int64(123), *out.Num)
-	assert.Equal(t, "myname", *out.Str)
-	assert.Equal(t, true, *out.TrueBool)
-
-}
-
-func TestOutputService2ProtocolTestBlobCase1(t *testing.T) {
-	svc := NewOutputService2ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Blob>dmFsdWU=</Blob><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService2TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "value", string(out.Blob))
-
-}
-
-func TestOutputService3ProtocolTestListsCase1(t *testing.T) {
-	svc := NewOutputService3ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember><member>abc</member><member>123</member></ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService3TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "abc", *out.ListMember[0])
-	assert.Equal(t, "123", *out.ListMember[1])
-
-}
-
-func TestOutputService4ProtocolTestListWithCustomMemberNameCase1(t *testing.T) {
-	svc := NewOutputService4ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember><item>abc</item><item>123</item></ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService4TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "abc", *out.ListMember[0])
-	assert.Equal(t, "123", *out.ListMember[1])
-
-}
-
-func TestOutputService5ProtocolTestFlattenedListCase1(t *testing.T) {
-	svc := NewOutputService5ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember>abc</ListMember><ListMember>123</ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService5TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "abc", *out.ListMember[0])
-	assert.Equal(t, "123", *out.ListMember[1])
-
-}
-
-func TestOutputService6ProtocolTestNormalMapCase1(t *testing.T) {
-	svc := NewOutputService6ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><entry><key>qux</key><value><foo>bar</foo></value></entry><entry><key>baz</key><value><foo>bam</foo></value></entry></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService6TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "bam", *out.Map["baz"].Foo)
-	assert.Equal(t, "bar", *out.Map["qux"].Foo)
-
-}
-
-func TestOutputService7ProtocolTestFlattenedMapCase1(t *testing.T) {
-	svc := NewOutputService7ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><key>qux</key><value>bar</value></Map><Map><key>baz</key><value>bam</value></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService7TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "bam", *out.Map["baz"])
-	assert.Equal(t, "bar", *out.Map["qux"])
-
-}
-
-func TestOutputService8ProtocolTestNamedMapCase1(t *testing.T) {
-	svc := NewOutputService8ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><foo>qux</foo><bar>bar</bar></Map><Map><foo>baz</foo><bar>bam</bar></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService8TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "bam", *out.Map["baz"])
-	assert.Equal(t, "bar", *out.Map["qux"])
-
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/build.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/build.go
@@ -1,33 +0,0 @@
-// Package query provides serialisation of AWS query requests, and responses.
-package query
-
-//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/input/query.json build_test.go
-
-import (
-	"net/url"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/internal/protocol/query/queryutil"
-)
-
-// Build builds a request for an AWS Query service.
-func Build(r *aws.Request) {
-	body := url.Values{
-		"Action":  {r.Operation.Name},
-		"Version": {r.Service.APIVersion},
-	}
-	if err := queryutil.Parse(body, r.Params, false); err != nil {
-		r.Error = awserr.New("SerializationError", "failed encoding Query request", err)
-		return
-	}
-
-	if r.ExpireTime == 0 {
-		r.HTTPRequest.Method = "POST"
-		r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
-		r.SetBufferBody([]byte(body.Encode()))
-	} else { // This is a pre-signed request
-		r.HTTPRequest.Method = "GET"
-		r.HTTPRequest.URL.RawQuery = body.Encode()
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/build_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/build_test.go
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/queryutil/queryutil.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/queryutil/queryutil.go
@@ -1,223 +0,0 @@
-package queryutil
-
-import (
-	"encoding/base64"
-	"fmt"
-	"net/url"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Parse parses an object i and fills a url.Values object. The isEC2 flag
-// indicates if this is the EC2 Query sub-protocol.
-func Parse(body url.Values, i interface{}, isEC2 bool) error {
-	q := queryParser{isEC2: isEC2}
-	return q.parseValue(body, reflect.ValueOf(i), "", "")
-}
-
-func elemOf(value reflect.Value) reflect.Value {
-	for value.Kind() == reflect.Ptr {
-		value = value.Elem()
-	}
-	return value
-}
-
-type queryParser struct {
-	isEC2 bool
-}
-
-func (q *queryParser) parseValue(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
-	value = elemOf(value)
-
-	// no need to handle zero values
-	if !value.IsValid() {
-		return nil
-	}
-
-	t := tag.Get("type")
-	if t == "" {
-		switch value.Kind() {
-		case reflect.Struct:
-			t = "structure"
-		case reflect.Slice:
-			t = "list"
-		case reflect.Map:
-			t = "map"
-		}
-	}
-
-	switch t {
-	case "structure":
-		return q.parseStruct(v, value, prefix)
-	case "list":
-		return q.parseList(v, value, prefix, tag)
-	case "map":
-		return q.parseMap(v, value, prefix, tag)
-	default:
-		return q.parseScalar(v, value, prefix, tag)
-	}
-}
-
-func (q *queryParser) parseStruct(v url.Values, value reflect.Value, prefix string) error {
-	if !value.IsValid() {
-		return nil
-	}
-
-	t := value.Type()
-	for i := 0; i < value.NumField(); i++ {
-		if c := t.Field(i).Name[0:1]; strings.ToLower(c) == c {
-			continue // ignore unexported fields
-		}
-
-		value := elemOf(value.Field(i))
-		field := t.Field(i)
-		var name string
-
-		if q.isEC2 {
-			name = field.Tag.Get("queryName")
-		}
-		if name == "" {
-			if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {
-				name = field.Tag.Get("locationNameList")
-			} else if locName := field.Tag.Get("locationName"); locName != "" {
-				name = locName
-			}
-			if name != "" && q.isEC2 {
-				name = strings.ToUpper(name[0:1]) + name[1:]
-			}
-		}
-		if name == "" {
-			name = field.Name
-		}
-
-		if prefix != "" {
-			name = prefix + "." + name
-		}
-
-		if err := q.parseValue(v, value, name, field.Tag); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (q *queryParser) parseList(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
-	// If it's empty, generate an empty value
-	if !value.IsNil() && value.Len() == 0 {
-		v.Set(prefix, "")
-		return nil
-	}
-
-	// check for unflattened list member
-	if !q.isEC2 && tag.Get("flattened") == "" {
-		prefix += ".member"
-	}
-
-	for i := 0; i < value.Len(); i++ {
-		slicePrefix := prefix
-		if slicePrefix == "" {
-			slicePrefix = strconv.Itoa(i + 1)
-		} else {
-			slicePrefix = slicePrefix + "." + strconv.Itoa(i+1)
-		}
-		if err := q.parseValue(v, value.Index(i), slicePrefix, ""); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (q *queryParser) parseMap(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
-	// If it's empty, generate an empty value
-	if !value.IsNil() && value.Len() == 0 {
-		v.Set(prefix, "")
-		return nil
-	}
-
-	// check for unflattened list member
-	if !q.isEC2 && tag.Get("flattened") == "" {
-		prefix += ".entry"
-	}
-
-	// sort keys for improved serialization consistency.
-	// this is not strictly necessary for protocol support.
-	mapKeyValues := value.MapKeys()
-	mapKeys := map[string]reflect.Value{}
-	mapKeyNames := make([]string, len(mapKeyValues))
-	for i, mapKey := range mapKeyValues {
-		name := mapKey.String()
-		mapKeys[name] = mapKey
-		mapKeyNames[i] = name
-	}
-	sort.Strings(mapKeyNames)
-
-	for i, mapKeyName := range mapKeyNames {
-		mapKey := mapKeys[mapKeyName]
-		mapValue := value.MapIndex(mapKey)
-
-		kname := tag.Get("locationNameKey")
-		if kname == "" {
-			kname = "key"
-		}
-		vname := tag.Get("locationNameValue")
-		if vname == "" {
-			vname = "value"
-		}
-
-		// serialize key
-		var keyName string
-		if prefix == "" {
-			keyName = strconv.Itoa(i+1) + "." + kname
-		} else {
-			keyName = prefix + "." + strconv.Itoa(i+1) + "." + kname
-		}
-
-		if err := q.parseValue(v, mapKey, keyName, ""); err != nil {
-			return err
-		}
-
-		// serialize value
-		var valueName string
-		if prefix == "" {
-			valueName = strconv.Itoa(i+1) + "." + vname
-		} else {
-			valueName = prefix + "." + strconv.Itoa(i+1) + "." + vname
-		}
-
-		if err := q.parseValue(v, mapValue, valueName, ""); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (q *queryParser) parseScalar(v url.Values, r reflect.Value, name string, tag reflect.StructTag) error {
-	switch value := r.Interface().(type) {
-	case string:
-		v.Set(name, value)
-	case []byte:
-		if !r.IsNil() {
-			v.Set(name, base64.StdEncoding.EncodeToString(value))
-		}
-	case bool:
-		v.Set(name, strconv.FormatBool(value))
-	case int64:
-		v.Set(name, strconv.FormatInt(value, 10))
-	case int:
-		v.Set(name, strconv.Itoa(value))
-	case float64:
-		v.Set(name, strconv.FormatFloat(value, 'f', -1, 64))
-	case float32:
-		v.Set(name, strconv.FormatFloat(float64(value), 'f', -1, 32))
-	case time.Time:
-		const ISO8601UTC = "2006-01-02T15:04:05Z"
-		v.Set(name, value.UTC().Format(ISO8601UTC))
-	default:
-		return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name())
-	}
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/unmarshal.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/unmarshal.go
@@ -1,29 +0,0 @@
-package query
-
-//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/output/query.json unmarshal_test.go
-
-import (
-	"encoding/xml"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-)
-
-// Unmarshal unmarshals a response for an AWS Query service.
-func Unmarshal(r *aws.Request) {
-	defer r.HTTPResponse.Body.Close()
-	if r.DataFilled() {
-		decoder := xml.NewDecoder(r.HTTPResponse.Body)
-		err := xmlutil.UnmarshalXML(r.Data, decoder, r.Operation.Name+"Result")
-		if err != nil {
-			r.Error = awserr.New("SerializationError", "failed decoding Query response", err)
-			return
-		}
-	}
-}
-
-// UnmarshalMeta unmarshals header response values for an AWS Query service.
-func UnmarshalMeta(r *aws.Request) {
-	// TODO implement unmarshaling of request IDs
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/unmarshal_error.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/unmarshal_error.go
@@ -1,33 +0,0 @@
-package query
-
-import (
-	"encoding/xml"
-	"io"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-type xmlErrorResponse struct {
-	XMLName   xml.Name `xml:"ErrorResponse"`
-	Code      string   `xml:"Error>Code"`
-	Message   string   `xml:"Error>Message"`
-	RequestID string   `xml:"RequestId"`
-}
-
-// UnmarshalError unmarshals an error response for an AWS Query service.
-func UnmarshalError(r *aws.Request) {
-	defer r.HTTPResponse.Body.Close()
-
-	resp := &xmlErrorResponse{}
-	err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
-	if err != nil && err != io.EOF {
-		r.Error = awserr.New("SerializationError", "failed to decode query XML error response", err)
-	} else {
-		r.Error = awserr.NewRequestFailure(
-			awserr.New(resp.Code, resp.Message, nil),
-			r.HTTPResponse.StatusCode,
-			resp.RequestID,
-		)
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/unmarshal_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/unmarshal_test.go
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/rest/build.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/rest/build.go
@@ -1,217 +0,0 @@
-// Package rest provides RESTful serialisation of AWS requests and responses.
-package rest
-
-import (
-	"bytes"
-	"encoding/base64"
-	"fmt"
-	"io"
-	"net/url"
-	"path"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-// RFC822 returns an RFC822 formatted timestamp for AWS protocols
-const RFC822 = "Mon, 2 Jan 2006 15:04:05 GMT"
-
-// Whether the byte value can be sent without escaping in AWS URLs
-var noEscape [256]bool
-
-func init() {
-	for i := 0; i < len(noEscape); i++ {
-		// AWS expects every character except these to be escaped
-		noEscape[i] = (i >= 'A' && i <= 'Z') ||
-			(i >= 'a' && i <= 'z') ||
-			(i >= '0' && i <= '9') ||
-			i == '-' ||
-			i == '.' ||
-			i == '_' ||
-			i == '~'
-	}
-}
-
-// Build builds the REST component of a service request.
-func Build(r *aws.Request) {
-	if r.ParamsFilled() {
-		v := reflect.ValueOf(r.Params).Elem()
-		buildLocationElements(r, v)
-		buildBody(r, v)
-	}
-}
-
-func buildLocationElements(r *aws.Request, v reflect.Value) {
-	query := r.HTTPRequest.URL.Query()
-
-	for i := 0; i < v.NumField(); i++ {
-		m := v.Field(i)
-		if n := v.Type().Field(i).Name; n[0:1] == strings.ToLower(n[0:1]) {
-			continue
-		}
-
-		if m.IsValid() {
-			field := v.Type().Field(i)
-			name := field.Tag.Get("locationName")
-			if name == "" {
-				name = field.Name
-			}
-			if m.Kind() == reflect.Ptr {
-				m = m.Elem()
-			}
-			if !m.IsValid() {
-				continue
-			}
-
-			switch field.Tag.Get("location") {
-			case "headers": // header maps
-				buildHeaderMap(r, m, field.Tag.Get("locationName"))
-			case "header":
-				buildHeader(r, m, name)
-			case "uri":
-				buildURI(r, m, name)
-			case "querystring":
-				buildQueryString(r, m, name, query)
-			}
-		}
-		if r.Error != nil {
-			return
-		}
-	}
-
-	r.HTTPRequest.URL.RawQuery = query.Encode()
-	updatePath(r.HTTPRequest.URL, r.HTTPRequest.URL.Path)
-}
-
-func buildBody(r *aws.Request, v reflect.Value) {
-	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
-		if payloadName := field.Tag.Get("payload"); payloadName != "" {
-			pfield, _ := v.Type().FieldByName(payloadName)
-			if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {
-				payload := reflect.Indirect(v.FieldByName(payloadName))
-				if payload.IsValid() && payload.Interface() != nil {
-					switch reader := payload.Interface().(type) {
-					case io.ReadSeeker:
-						r.SetReaderBody(reader)
-					case []byte:
-						r.SetBufferBody(reader)
-					case string:
-						r.SetStringBody(reader)
-					default:
-						r.Error = awserr.New("SerializationError",
-							"failed to encode REST request",
-							fmt.Errorf("unknown payload type %s", payload.Type()))
-					}
-				}
-			}
-		}
-	}
-}
-
-func buildHeader(r *aws.Request, v reflect.Value, name string) {
-	str, err := convertType(v)
-	if err != nil {
-		r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
-	} else if str != nil {
-		r.HTTPRequest.Header.Add(name, *str)
-	}
-}
-
-func buildHeaderMap(r *aws.Request, v reflect.Value, prefix string) {
-	for _, key := range v.MapKeys() {
-		str, err := convertType(v.MapIndex(key))
-		if err != nil {
-			r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
-		} else if str != nil {
-			r.HTTPRequest.Header.Add(prefix+key.String(), *str)
-		}
-	}
-}
-
-func buildURI(r *aws.Request, v reflect.Value, name string) {
-	value, err := convertType(v)
-	if err != nil {
-		r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
-	} else if value != nil {
-		uri := r.HTTPRequest.URL.Path
-		uri = strings.Replace(uri, "{"+name+"}", EscapePath(*value, true), -1)
-		uri = strings.Replace(uri, "{"+name+"+}", EscapePath(*value, false), -1)
-		r.HTTPRequest.URL.Path = uri
-	}
-}
-
-func buildQueryString(r *aws.Request, v reflect.Value, name string, query url.Values) {
-	str, err := convertType(v)
-	if err != nil {
-		r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
-	} else if str != nil {
-		query.Set(name, *str)
-	}
-}
-
-func updatePath(url *url.URL, urlPath string) {
-	scheme, query := url.Scheme, url.RawQuery
-
-	hasSlash := strings.HasSuffix(urlPath, "/")
-
-	// clean up path
-	urlPath = path.Clean(urlPath)
-	if hasSlash && !strings.HasSuffix(urlPath, "/") {
-		urlPath += "/"
-	}
-
-	// get formatted URL minus scheme so we can build this into Opaque
-	url.Scheme, url.Path, url.RawQuery = "", "", ""
-	s := url.String()
-	url.Scheme = scheme
-	url.RawQuery = query
-
-	// build opaque URI
-	url.Opaque = s + urlPath
-}
-
-// EscapePath escapes part of a URL path in Amazon style
-func EscapePath(path string, encodeSep bool) string {
-	var buf bytes.Buffer
-	for i := 0; i < len(path); i++ {
-		c := path[i]
-		if noEscape[c] || (c == '/' && !encodeSep) {
-			buf.WriteByte(c)
-		} else {
-			buf.WriteByte('%')
-			buf.WriteString(strings.ToUpper(strconv.FormatUint(uint64(c), 16)))
-		}
-	}
-	return buf.String()
-}
-
-func convertType(v reflect.Value) (*string, error) {
-	v = reflect.Indirect(v)
-	if !v.IsValid() {
-		return nil, nil
-	}
-
-	var str string
-	switch value := v.Interface().(type) {
-	case string:
-		str = value
-	case []byte:
-		str = base64.StdEncoding.EncodeToString(value)
-	case bool:
-		str = strconv.FormatBool(value)
-	case int64:
-		str = strconv.FormatInt(value, 10)
-	case float64:
-		str = strconv.FormatFloat(value, 'f', -1, 64)
-	case time.Time:
-		str = value.UTC().Format(RFC822)
-	default:
-		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
-		return nil, err
-	}
-	return &str, nil
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/rest/unmarshal.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/rest/unmarshal.go
@@ -1,174 +0,0 @@
-package rest
-
-import (
-	"encoding/base64"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-// Unmarshal unmarshals the REST component of a response in a REST service.
-func Unmarshal(r *aws.Request) {
-	if r.DataFilled() {
-		v := reflect.Indirect(reflect.ValueOf(r.Data))
-		unmarshalBody(r, v)
-		unmarshalLocationElements(r, v)
-	}
-}
-
-func unmarshalBody(r *aws.Request, v reflect.Value) {
-	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
-		if payloadName := field.Tag.Get("payload"); payloadName != "" {
-			pfield, _ := v.Type().FieldByName(payloadName)
-			if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {
-				payload := v.FieldByName(payloadName)
-				if payload.IsValid() {
-					switch payload.Interface().(type) {
-					case []byte:
-						b, err := ioutil.ReadAll(r.HTTPResponse.Body)
-						if err != nil {
-							r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
-						} else {
-							payload.Set(reflect.ValueOf(b))
-						}
-					case *string:
-						b, err := ioutil.ReadAll(r.HTTPResponse.Body)
-						if err != nil {
-							r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
-						} else {
-							str := string(b)
-							payload.Set(reflect.ValueOf(&str))
-						}
-					default:
-						switch payload.Type().String() {
-						case "io.ReadSeeker":
-							payload.Set(reflect.ValueOf(aws.ReadSeekCloser(r.HTTPResponse.Body)))
-						case "aws.ReadSeekCloser", "io.ReadCloser":
-							payload.Set(reflect.ValueOf(r.HTTPResponse.Body))
-						default:
-							r.Error = awserr.New("SerializationError",
-								"failed to decode REST response",
-								fmt.Errorf("unknown payload type %s", payload.Type()))
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-func unmarshalLocationElements(r *aws.Request, v reflect.Value) {
-	for i := 0; i < v.NumField(); i++ {
-		m, field := v.Field(i), v.Type().Field(i)
-		if n := field.Name; n[0:1] == strings.ToLower(n[0:1]) {
-			continue
-		}
-
-		if m.IsValid() {
-			name := field.Tag.Get("locationName")
-			if name == "" {
-				name = field.Name
-			}
-
-			switch field.Tag.Get("location") {
-			case "statusCode":
-				unmarshalStatusCode(m, r.HTTPResponse.StatusCode)
-			case "header":
-				err := unmarshalHeader(m, r.HTTPResponse.Header.Get(name))
-				if err != nil {
-					r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
-					break
-				}
-			case "headers":
-				prefix := field.Tag.Get("locationName")
-				err := unmarshalHeaderMap(m, r.HTTPResponse.Header, prefix)
-				if err != nil {
-					r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
-					break
-				}
-			}
-		}
-		if r.Error != nil {
-			return
-		}
-	}
-}
-
-func unmarshalStatusCode(v reflect.Value, statusCode int) {
-	if !v.IsValid() {
-		return
-	}
-
-	switch v.Interface().(type) {
-	case *int64:
-		s := int64(statusCode)
-		v.Set(reflect.ValueOf(&s))
-	}
-}
-
-func unmarshalHeaderMap(r reflect.Value, headers http.Header, prefix string) error {
-	switch r.Interface().(type) {
-	case map[string]*string: // we only support string map value types
-		out := map[string]*string{}
-		for k, v := range headers {
-			k = http.CanonicalHeaderKey(k)
-			if strings.HasPrefix(strings.ToLower(k), strings.ToLower(prefix)) {
-				out[k[len(prefix):]] = &v[0]
-			}
-		}
-		r.Set(reflect.ValueOf(out))
-	}
-	return nil
-}
-
-func unmarshalHeader(v reflect.Value, header string) error {
-	if !v.IsValid() || (header == "" && v.Elem().Kind() != reflect.String) {
-		return nil
-	}
-
-	switch v.Interface().(type) {
-	case *string:
-		v.Set(reflect.ValueOf(&header))
-	case []byte:
-		b, err := base64.StdEncoding.DecodeString(header)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&b))
-	case *bool:
-		b, err := strconv.ParseBool(header)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&b))
-	case *int64:
-		i, err := strconv.ParseInt(header, 10, 64)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&i))
-	case *float64:
-		f, err := strconv.ParseFloat(header, 64)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&f))
-	case *time.Time:
-		t, err := time.Parse(RFC822, header)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&t))
-	default:
-		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
-		return err
-	}
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil/build.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil/build.go
@@ -1,287 +0,0 @@
-// Package xmlutil provides XML serialisation of AWS requests and responses.
-package xmlutil
-
-import (
-	"encoding/base64"
-	"encoding/xml"
-	"fmt"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// BuildXML will serialize params into an xml.Encoder.
-// Error will be returned if the serialization of any of the params or nested values fails.
-func BuildXML(params interface{}, e *xml.Encoder) error {
-	b := xmlBuilder{encoder: e, namespaces: map[string]string{}}
-	root := NewXMLElement(xml.Name{})
-	if err := b.buildValue(reflect.ValueOf(params), root, ""); err != nil {
-		return err
-	}
-	for _, c := range root.Children {
-		for _, v := range c {
-			return StructToXML(e, v, false)
-		}
-	}
-	return nil
-}
-
-// Returns the reflection element of a value, if it is a pointer.
-func elemOf(value reflect.Value) reflect.Value {
-	for value.Kind() == reflect.Ptr {
-		value = value.Elem()
-	}
-	return value
-}
-
-// A xmlBuilder serializes values from Go code to XML
-type xmlBuilder struct {
-	encoder    *xml.Encoder
-	namespaces map[string]string
-}
-
-// buildValue generic XMLNode builder for any type. Will build value for their specific type
-// struct, list, map, scalar.
-//
-// Also takes a "type" tag value to set what type a value should be converted to XMLNode as. If
-// type is not provided reflect will be used to determine the value's type.
-func (b *xmlBuilder) buildValue(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	value = elemOf(value)
-	if !value.IsValid() { // no need to handle zero values
-		return nil
-	} else if tag.Get("location") != "" { // don't handle non-body location values
-		return nil
-	}
-
-	t := tag.Get("type")
-	if t == "" {
-		switch value.Kind() {
-		case reflect.Struct:
-			t = "structure"
-		case reflect.Slice:
-			t = "list"
-		case reflect.Map:
-			t = "map"
-		}
-	}
-
-	switch t {
-	case "structure":
-		if field, ok := value.Type().FieldByName("SDKShapeTraits"); ok {
-			tag = tag + reflect.StructTag(" ") + field.Tag
-		}
-		return b.buildStruct(value, current, tag)
-	case "list":
-		return b.buildList(value, current, tag)
-	case "map":
-		return b.buildMap(value, current, tag)
-	default:
-		return b.buildScalar(value, current, tag)
-	}
-}
-
-// buildStruct adds a struct and its fields to the current XMLNode. All fields any any nested
-// types are converted to XMLNodes also.
-func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	if !value.IsValid() {
-		return nil
-	}
-
-	fieldAdded := false
-
-	// unwrap payloads
-	if payload := tag.Get("payload"); payload != "" {
-		field, _ := value.Type().FieldByName(payload)
-		tag = field.Tag
-		value = elemOf(value.FieldByName(payload))
-
-		if !value.IsValid() {
-			return nil
-		}
-	}
-
-	child := NewXMLElement(xml.Name{Local: tag.Get("locationName")})
-
-	// there is an xmlNamespace associated with this struct
-	if prefix, uri := tag.Get("xmlPrefix"), tag.Get("xmlURI"); uri != "" {
-		ns := xml.Attr{
-			Name:  xml.Name{Local: "xmlns"},
-			Value: uri,
-		}
-		if prefix != "" {
-			b.namespaces[prefix] = uri // register the namespace
-			ns.Name.Local = "xmlns:" + prefix
-		}
-
-		child.Attr = append(child.Attr, ns)
-	}
-
-	t := value.Type()
-	for i := 0; i < value.NumField(); i++ {
-		if c := t.Field(i).Name[0:1]; strings.ToLower(c) == c {
-			continue // ignore unexported fields
-		}
-
-		member := elemOf(value.Field(i))
-		field := t.Field(i)
-		mTag := field.Tag
-
-		if mTag.Get("location") != "" { // skip non-body members
-			continue
-		}
-
-		memberName := mTag.Get("locationName")
-		if memberName == "" {
-			memberName = field.Name
-			mTag = reflect.StructTag(string(mTag) + ` locationName:"` + memberName + `"`)
-		}
-		if err := b.buildValue(member, child, mTag); err != nil {
-			return err
-		}
-
-		fieldAdded = true
-	}
-
-	if fieldAdded { // only append this child if we have one ore more valid members
-		current.AddChild(child)
-	}
-
-	return nil
-}
-
-// buildList adds the value's list items to the current XMLNode as children nodes. All
-// nested values in the list are converted to XMLNodes also.
-func (b *xmlBuilder) buildList(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	if value.IsNil() { // don't build omitted lists
-		return nil
-	}
-
-	// check for unflattened list member
-	flattened := tag.Get("flattened") != ""
-
-	xname := xml.Name{Local: tag.Get("locationName")}
-	if flattened {
-		for i := 0; i < value.Len(); i++ {
-			child := NewXMLElement(xname)
-			current.AddChild(child)
-			if err := b.buildValue(value.Index(i), child, ""); err != nil {
-				return err
-			}
-		}
-	} else {
-		list := NewXMLElement(xname)
-		current.AddChild(list)
-
-		for i := 0; i < value.Len(); i++ {
-			iname := tag.Get("locationNameList")
-			if iname == "" {
-				iname = "member"
-			}
-
-			child := NewXMLElement(xml.Name{Local: iname})
-			list.AddChild(child)
-			if err := b.buildValue(value.Index(i), child, ""); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-// buildMap adds the value's key/value pairs to the current XMLNode as children nodes. All
-// nested values in the map are converted to XMLNodes also.
-//
-// Error will be returned if it is unable to build the map's values into XMLNodes
-func (b *xmlBuilder) buildMap(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	if value.IsNil() { // don't build omitted maps
-		return nil
-	}
-
-	maproot := NewXMLElement(xml.Name{Local: tag.Get("locationName")})
-	current.AddChild(maproot)
-	current = maproot
-
-	kname, vname := "key", "value"
-	if n := tag.Get("locationNameKey"); n != "" {
-		kname = n
-	}
-	if n := tag.Get("locationNameValue"); n != "" {
-		vname = n
-	}
-
-	// sorting is not required for compliance, but it makes testing easier
-	keys := make([]string, value.Len())
-	for i, k := range value.MapKeys() {
-		keys[i] = k.String()
-	}
-	sort.Strings(keys)
-
-	for _, k := range keys {
-		v := value.MapIndex(reflect.ValueOf(k))
-
-		mapcur := current
-		if tag.Get("flattened") == "" { // add "entry" tag to non-flat maps
-			child := NewXMLElement(xml.Name{Local: "entry"})
-			mapcur.AddChild(child)
-			mapcur = child
-		}
-
-		kchild := NewXMLElement(xml.Name{Local: kname})
-		kchild.Text = k
-		vchild := NewXMLElement(xml.Name{Local: vname})
-		mapcur.AddChild(kchild)
-		mapcur.AddChild(vchild)
-
-		if err := b.buildValue(v, vchild, ""); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// buildScalar will convert the value into a string and append it as a attribute or child
-// of the current XMLNode.
-//
-// The value will be added as an attribute if tag contains a "xmlAttribute" attribute value.
-//
-// Error will be returned if the value type is unsupported.
-func (b *xmlBuilder) buildScalar(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	var str string
-	switch converted := value.Interface().(type) {
-	case string:
-		str = converted
-	case []byte:
-		if !value.IsNil() {
-			str = base64.StdEncoding.EncodeToString(converted)
-		}
-	case bool:
-		str = strconv.FormatBool(converted)
-	case int64:
-		str = strconv.FormatInt(converted, 10)
-	case int:
-		str = strconv.Itoa(converted)
-	case float64:
-		str = strconv.FormatFloat(converted, 'f', -1, 64)
-	case float32:
-		str = strconv.FormatFloat(float64(converted), 'f', -1, 32)
-	case time.Time:
-		const ISO8601UTC = "2006-01-02T15:04:05Z"
-		str = converted.UTC().Format(ISO8601UTC)
-	default:
-		return fmt.Errorf("unsupported value for param %s: %v (%s)",
-			tag.Get("locationName"), value.Interface(), value.Type().Name())
-	}
-
-	xname := xml.Name{Local: tag.Get("locationName")}
-	if tag.Get("xmlAttribute") != "" { // put into current node's attribute list
-		attr := xml.Attr{Name: xname, Value: str}
-		current.Attr = append(current.Attr, attr)
-	} else { // regular text node
-		current.AddChild(&XMLNode{Name: xname, Text: str})
-	}
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4/functional_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4/functional_test.go
@@ -1,43 +0,0 @@
-package v4_test
-
-import (
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-
-func TestPresignHandler(t *testing.T) {
-	svc := s3.New(nil)
-	req, _ := svc.PutObjectRequest(&s3.PutObjectInput{
-		Bucket:             aws.String("bucket"),
-		Key:                aws.String("key"),
-		ContentDisposition: aws.String("a+b c$d"),
-		ACL:                aws.String("public-read"),
-	})
-	req.Time = time.Unix(0, 0)
-	urlstr, err := req.Presign(5 * time.Minute)
-
-	assert.NoError(t, err)
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-acl"
-	expectedSig := "7edcb4e3a1bf12f4989018d75acbe3a7f03df24bd6f3112602d59fc551f0e4e2"
-	expectedCred := "AKID/19700101/mock-region/s3/aws4_request"
-
-	u, _ := url.Parse(urlstr)
-	urlQ := u.Query()
-	assert.Equal(t, expectedSig, urlQ.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, urlQ.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, urlQ.Get("X-Amz-Date"))
-	assert.Equal(t, "300", urlQ.Get("X-Amz-Expires"))
-
-	assert.NotContains(t, urlstr, "+") // + encoded as %20
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4/v4.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4/v4.go
@@ -1,364 +0,0 @@
-// Package v4 implements signing for AWS V4 signer
-package v4
-
-import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/internal/protocol/rest"
-)
-
-const (
-	authHeaderPrefix = "AWS4-HMAC-SHA256"
-	timeFormat       = "20060102T150405Z"
-	shortTimeFormat  = "20060102"
-)
-
-var ignoredHeaders = map[string]bool{
-	"Authorization":  true,
-	"Content-Type":   true,
-	"Content-Length": true,
-	"User-Agent":     true,
-}
-
-type signer struct {
-	Request     *http.Request
-	Time        time.Time
-	ExpireTime  time.Duration
-	ServiceName string
-	Region      string
-	CredValues  credentials.Value
-	Credentials *credentials.Credentials
-	Query       url.Values
-	Body        io.ReadSeeker
-	Debug       aws.LogLevelType
-	Logger      aws.Logger
-
-	isPresign          bool
-	formattedTime      string
-	formattedShortTime string
-
-	signedHeaders    string
-	canonicalHeaders string
-	canonicalString  string
-	credentialString string
-	stringToSign     string
-	signature        string
-	authorization    string
-}
-
-// Sign requests with signature version 4.
-//
-// Will sign the requests with the service config's Credentials object
-// Signing is skipped if the credentials is the credentials.AnonymousCredentials
-// object.
-func Sign(req *aws.Request) {
-	// If the request does not need to be signed ignore the signing of the
-	// request if the AnonymousCredentials object is used.
-	if req.Service.Config.Credentials == credentials.AnonymousCredentials {
-		return
-	}
-
-	region := req.Service.SigningRegion
-	if region == "" {
-		region = aws.StringValue(req.Service.Config.Region)
-	}
-
-	name := req.Service.SigningName
-	if name == "" {
-		name = req.Service.ServiceName
-	}
-
-	s := signer{
-		Request:     req.HTTPRequest,
-		Time:        req.Time,
-		ExpireTime:  req.ExpireTime,
-		Query:       req.HTTPRequest.URL.Query(),
-		Body:        req.Body,
-		ServiceName: name,
-		Region:      region,
-		Credentials: req.Service.Config.Credentials,
-		Debug:       req.Service.Config.LogLevel.Value(),
-		Logger:      req.Service.Config.Logger,
-	}
-
-	req.Error = s.sign()
-}
-
-func (v4 *signer) sign() error {
-	if v4.ExpireTime != 0 {
-		v4.isPresign = true
-	}
-
-	if v4.isRequestSigned() {
-		if !v4.Credentials.IsExpired() {
-			// If the request is already signed, and the credentials have not
-			// expired yet ignore the signing request.
-			return nil
-		}
-
-		// The credentials have expired for this request. The current signing
-		// is invalid, and needs to be request because the request will fail.
-		if v4.isPresign {
-			v4.removePresign()
-			// Update the request's query string to ensure the values stays in
-			// sync in the case retrieving the new credentials fails.
-			v4.Request.URL.RawQuery = v4.Query.Encode()
-		}
-	}
-
-	var err error
-	v4.CredValues, err = v4.Credentials.Get()
-	if err != nil {
-		return err
-	}
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-Algorithm", authHeaderPrefix)
-		if v4.CredValues.SessionToken != "" {
-			v4.Query.Set("X-Amz-Security-Token", v4.CredValues.SessionToken)
-		} else {
-			v4.Query.Del("X-Amz-Security-Token")
-		}
-	} else if v4.CredValues.SessionToken != "" {
-		v4.Request.Header.Set("X-Amz-Security-Token", v4.CredValues.SessionToken)
-	}
-
-	v4.build()
-
-	if v4.Debug.Matches(aws.LogDebugWithSigning) {
-		v4.logSigningInfo()
-	}
-
-	return nil
-}
-
-const logSignInfoMsg = `DEBUG: Request Signiture:
---[ CANONICAL STRING  ]-----------------------------
-%s
---[ STRING TO SIGN ]--------------------------------
-%s%s
-----------------------------------------------------`
-const logSignedURLMsg = `
---[ SIGNED URL ]------------------------------------
-%s`
-
-func (v4 *signer) logSigningInfo() {
-	signedURLMsg := ""
-	if v4.isPresign {
-		signedURLMsg = fmt.Sprintf(logSignedURLMsg, v4.Request.URL.String())
-	}
-	msg := fmt.Sprintf(logSignInfoMsg, v4.canonicalString, v4.stringToSign, signedURLMsg)
-	v4.Logger.Log(msg)
-}
-
-func (v4 *signer) build() {
-	v4.buildTime()             // no depends
-	v4.buildCredentialString() // no depends
-	if v4.isPresign {
-		v4.buildQuery() // no depends
-	}
-	v4.buildCanonicalHeaders() // depends on cred string
-	v4.buildCanonicalString()  // depends on canon headers / signed headers
-	v4.buildStringToSign()     // depends on canon string
-	v4.buildSignature()        // depends on string to sign
-
-	if v4.isPresign {
-		v4.Request.URL.RawQuery += "&X-Amz-Signature=" + v4.signature
-	} else {
-		parts := []string{
-			authHeaderPrefix + " Credential=" + v4.CredValues.AccessKeyID + "/" + v4.credentialString,
-			"SignedHeaders=" + v4.signedHeaders,
-			"Signature=" + v4.signature,
-		}
-		v4.Request.Header.Set("Authorization", strings.Join(parts, ", "))
-	}
-}
-
-func (v4 *signer) buildTime() {
-	v4.formattedTime = v4.Time.UTC().Format(timeFormat)
-	v4.formattedShortTime = v4.Time.UTC().Format(shortTimeFormat)
-
-	if v4.isPresign {
-		duration := int64(v4.ExpireTime / time.Second)
-		v4.Query.Set("X-Amz-Date", v4.formattedTime)
-		v4.Query.Set("X-Amz-Expires", strconv.FormatInt(duration, 10))
-	} else {
-		v4.Request.Header.Set("X-Amz-Date", v4.formattedTime)
-	}
-}
-
-func (v4 *signer) buildCredentialString() {
-	v4.credentialString = strings.Join([]string{
-		v4.formattedShortTime,
-		v4.Region,
-		v4.ServiceName,
-		"aws4_request",
-	}, "/")
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-Credential", v4.CredValues.AccessKeyID+"/"+v4.credentialString)
-	}
-}
-
-func (v4 *signer) buildQuery() {
-	for k, h := range v4.Request.Header {
-		if strings.HasPrefix(http.CanonicalHeaderKey(k), "X-Amz-") {
-			continue // never hoist x-amz-* headers, they must be signed
-		}
-		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
-			continue // never hoist ignored headers
-		}
-
-		v4.Request.Header.Del(k)
-		v4.Query.Del(k)
-		for _, v := range h {
-			v4.Query.Add(k, v)
-		}
-	}
-}
-
-func (v4 *signer) buildCanonicalHeaders() {
-	var headers []string
-	headers = append(headers, "host")
-	for k := range v4.Request.Header {
-		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
-			continue // ignored header
-		}
-		headers = append(headers, strings.ToLower(k))
-	}
-	sort.Strings(headers)
-
-	v4.signedHeaders = strings.Join(headers, ";")
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-SignedHeaders", v4.signedHeaders)
-	}
-
-	headerValues := make([]string, len(headers))
-	for i, k := range headers {
-		if k == "host" {
-			headerValues[i] = "host:" + v4.Request.URL.Host
-		} else {
-			headerValues[i] = k + ":" +
-				strings.Join(v4.Request.Header[http.CanonicalHeaderKey(k)], ",")
-		}
-	}
-
-	v4.canonicalHeaders = strings.Join(headerValues, "\n")
-}
-
-func (v4 *signer) buildCanonicalString() {
-	v4.Request.URL.RawQuery = strings.Replace(v4.Query.Encode(), "+", "%20", -1)
-	uri := v4.Request.URL.Opaque
-	if uri != "" {
-		uri = "/" + strings.Join(strings.Split(uri, "/")[3:], "/")
-	} else {
-		uri = v4.Request.URL.Path
-	}
-	if uri == "" {
-		uri = "/"
-	}
-
-	if v4.ServiceName != "s3" {
-		uri = rest.EscapePath(uri, false)
-	}
-
-	v4.canonicalString = strings.Join([]string{
-		v4.Request.Method,
-		uri,
-		v4.Request.URL.RawQuery,
-		v4.canonicalHeaders + "\n",
-		v4.signedHeaders,
-		v4.bodyDigest(),
-	}, "\n")
-}
-
-func (v4 *signer) buildStringToSign() {
-	v4.stringToSign = strings.Join([]string{
-		authHeaderPrefix,
-		v4.formattedTime,
-		v4.credentialString,
-		hex.EncodeToString(makeSha256([]byte(v4.canonicalString))),
-	}, "\n")
-}
-
-func (v4 *signer) buildSignature() {
-	secret := v4.CredValues.SecretAccessKey
-	date := makeHmac([]byte("AWS4"+secret), []byte(v4.formattedShortTime))
-	region := makeHmac(date, []byte(v4.Region))
-	service := makeHmac(region, []byte(v4.ServiceName))
-	credentials := makeHmac(service, []byte("aws4_request"))
-	signature := makeHmac(credentials, []byte(v4.stringToSign))
-	v4.signature = hex.EncodeToString(signature)
-}
-
-func (v4 *signer) bodyDigest() string {
-	hash := v4.Request.Header.Get("X-Amz-Content-Sha256")
-	if hash == "" {
-		if v4.isPresign && v4.ServiceName == "s3" {
-			hash = "UNSIGNED-PAYLOAD"
-		} else if v4.Body == nil {
-			hash = hex.EncodeToString(makeSha256([]byte{}))
-		} else {
-			hash = hex.EncodeToString(makeSha256Reader(v4.Body))
-		}
-		v4.Request.Header.Add("X-Amz-Content-Sha256", hash)
-	}
-	return hash
-}
-
-// isRequestSigned returns if the request is currently signed or presigned
-func (v4 *signer) isRequestSigned() bool {
-	if v4.isPresign && v4.Query.Get("X-Amz-Signature") != "" {
-		return true
-	}
-	if v4.Request.Header.Get("Authorization") != "" {
-		return true
-	}
-
-	return false
-}
-
-// unsign removes signing flags for both signed and presigned requests.
-func (v4 *signer) removePresign() {
-	v4.Query.Del("X-Amz-Algorithm")
-	v4.Query.Del("X-Amz-Signature")
-	v4.Query.Del("X-Amz-Security-Token")
-	v4.Query.Del("X-Amz-Date")
-	v4.Query.Del("X-Amz-Expires")
-	v4.Query.Del("X-Amz-Credential")
-	v4.Query.Del("X-Amz-SignedHeaders")
-}
-
-func makeHmac(key []byte, data []byte) []byte {
-	hash := hmac.New(sha256.New, key)
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-func makeSha256(data []byte) []byte {
-	hash := sha256.New()
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-func makeSha256Reader(reader io.ReadSeeker) []byte {
-	hash := sha256.New()
-	start, _ := reader.Seek(0, 1)
-	defer reader.Seek(start, 0)
-
-	io.Copy(hash, reader)
-	return hash.Sum(nil)
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4/v4_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4/v4_test.go
@@ -1,245 +0,0 @@
-package v4
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/stretchr/testify/assert"
-)
-
-func buildSigner(serviceName string, region string, signTime time.Time, expireTime time.Duration, body string) signer {
-	endpoint := "https://" + serviceName + "." + region + ".amazonaws.com"
-	reader := strings.NewReader(body)
-	req, _ := http.NewRequest("POST", endpoint, reader)
-	req.URL.Opaque = "//example.org/bucket/key-._~,!@#$%^&*()"
-	req.Header.Add("X-Amz-Target", "prefix.Operation")
-	req.Header.Add("Content-Type", "application/x-amz-json-1.0")
-	req.Header.Add("Content-Length", string(len(body)))
-	req.Header.Add("X-Amz-Meta-Other-Header", "some-value=!@#$%^&* (+)")
-
-	return signer{
-		Request:     req,
-		Time:        signTime,
-		ExpireTime:  expireTime,
-		Query:       req.URL.Query(),
-		Body:        reader,
-		ServiceName: serviceName,
-		Region:      region,
-		Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-	}
-}
-
-func removeWS(text string) string {
-	text = strings.Replace(text, " ", "", -1)
-	text = strings.Replace(text, "\n", "", -1)
-	text = strings.Replace(text, "\t", "", -1)
-	return text
-}
-
-func assertEqual(t *testing.T, expected, given string) {
-	if removeWS(expected) != removeWS(given) {
-		t.Errorf("\nExpected: %s\nGiven:    %s", expected, given)
-	}
-}
-
-func TestPresignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 300*time.Second, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-meta-other-header;x-amz-target"
-	expectedSig := "5eeedebf6f995145ce56daa02902d10485246d3defb34f97b973c1f40ab82d36"
-	expectedCred := "AKID/19700101/us-east-1/dynamodb/aws4_request"
-
-	q := signer.Request.URL.Query()
-	assert.Equal(t, expectedSig, q.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, q.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, q.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 0, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedSig := "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/dynamodb/aws4_request, SignedHeaders=host;x-amz-date;x-amz-meta-other-header;x-amz-security-token;x-amz-target, Signature=69ada33fec48180dab153576e4dd80c4e04124f80dda3eccfed8a67c2b91ed5e"
-
-	q := signer.Request.Header
-	assert.Equal(t, expectedSig, q.Get("Authorization"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignEmptyBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "")
-	signer.Body = nil
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", hash)
-}
-
-func TestSignBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-}
-
-func TestSignSeekedBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "   hello")
-	signer.Body.Read(make([]byte, 3)) // consume first 3 bytes so body is now "hello"
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-
-	start, _ := signer.Body.Seek(0, 1)
-	assert.Equal(t, int64(3), start)
-}
-
-func TestPresignEmptyBodyS3(t *testing.T) {
-	signer := buildSigner("s3", "us-east-1", time.Now(), 5*time.Minute, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "UNSIGNED-PAYLOAD", hash)
-}
-
-func TestSignPrecomputedBodyChecksum(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.Request.Header.Set("X-Amz-Content-Sha256", "PRECOMPUTED")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "PRECOMPUTED", hash)
-}
-
-func TestAnonymousCredentials(t *testing.T) {
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{Credentials: credentials.AnonymousCredentials}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-
-	urlQ := r.HTTPRequest.URL.Query()
-	assert.Empty(t, urlQ.Get("X-Amz-Signature"))
-	assert.Empty(t, urlQ.Get("X-Amz-Credential"))
-	assert.Empty(t, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Empty(t, urlQ.Get("X-Amz-Date"))
-
-	hQ := r.HTTPRequest.Header
-	assert.Empty(t, hQ.Get("Authorization"))
-	assert.Empty(t, hQ.Get("X-Amz-Date"))
-}
-
-func TestIgnoreResignRequestWithValidCreds(t *testing.T) {
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{
-			Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-			Region:      aws.String("us-west-2"),
-		}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("Authorization")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestIgnorePreResignRequestWithValidCreds(t *testing.T) {
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{
-			Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-			Region:      aws.String("us-west-2"),
-		}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("X-Amz-Signature")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("X-Amz-Signature"))
-}
-
-func TestResignRequestExpiredCreds(t *testing.T) {
-	creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION")
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{Credentials: creds}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-	querySig := r.HTTPRequest.Header.Get("Authorization")
-
-	creds.Expire()
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestPreResignRequestExpiredCreds(t *testing.T) {
-	provider := &credentials.StaticProvider{credentials.Value{"AKID", "SECRET", "SESSION"}}
-	creds := credentials.NewCredentials(provider)
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{Credentials: creds}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	querySig := r.HTTPRequest.URL.Query().Get("X-Amz-Signature")
-
-	creds.Expire()
-	r.Time = time.Now().Add(time.Hour * 48)
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.URL.Query().Get("X-Amz-Signature"))
-}
-
-func BenchmarkPresignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 300*time.Second, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}
-
-func BenchmarkSignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/endpoints/endpoints_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/endpoints/endpoints_test.go
@@ -1,41 +0,0 @@
-package endpoints_test
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/private/endpoints"
-)
-
-func TestGenericEndpoint(t *testing.T) {
-	name := "service"
-	region := "mock-region-1"
-
-	ep, sr := endpoints.EndpointForRegion(name, region, false)
-	assert.Equal(t, fmt.Sprintf("https://%s.%s.amazonaws.com", name, region), ep)
-	assert.Empty(t, sr)
-}
-
-func TestGlobalEndpoints(t *testing.T) {
-	region := "mock-region-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts", "waf"}
-
-	for _, name := range svcs {
-		ep, sr := endpoints.EndpointForRegion(name, region, false)
-		assert.Equal(t, fmt.Sprintf("https://%s.amazonaws.com", name), ep)
-		assert.Equal(t, "us-east-1", sr)
-	}
-}
-
-func TestServicesInCN(t *testing.T) {
-	region := "cn-north-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts", "s3", "waf"}
-
-	for _, name := range svcs {
-		ep, sr := endpoints.EndpointForRegion(name, region, false)
-		assert.Equal(t, fmt.Sprintf("https://%s.%s.amazonaws.com.cn", name, region), ep)
-		assert.Empty(t, sr)
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/ec2query/build_bench_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/ec2query/build_bench_test.go
@@ -1,85 +0,0 @@
-// +build bench
-
-package ec2query_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-	"github.com/aws/aws-sdk-go/private/protocol/ec2query"
-	"github.com/aws/aws-sdk-go/service/ec2"
-)
-
-func BenchmarkEC2QueryBuild_Complex_ec2AuthorizeSecurityGroupEgress(b *testing.B) {
-	params := &ec2.AuthorizeSecurityGroupEgressInput{
-		GroupId:  aws.String("String"), // Required
-		CidrIp:   aws.String("String"),
-		DryRun:   aws.Bool(true),
-		FromPort: aws.Int64(1),
-		IpPermissions: []*ec2.IpPermission{
-			{ // Required
-				FromPort:   aws.Int64(1),
-				IpProtocol: aws.String("String"),
-				IpRanges: []*ec2.IpRange{
-					{ // Required
-						CidrIp: aws.String("String"),
-					},
-					// More values...
-				},
-				PrefixListIds: []*ec2.PrefixListId{
-					{ // Required
-						PrefixListId: aws.String("String"),
-					},
-					// More values...
-				},
-				ToPort: aws.Int64(1),
-				UserIdGroupPairs: []*ec2.UserIdGroupPair{
-					{ // Required
-						GroupId:   aws.String("String"),
-						GroupName: aws.String("String"),
-						UserId:    aws.String("String"),
-					},
-					// More values...
-				},
-			},
-			// More values...
-		},
-		IpProtocol:                 aws.String("String"),
-		SourceSecurityGroupName:    aws.String("String"),
-		SourceSecurityGroupOwnerId: aws.String("String"),
-		ToPort: aws.Int64(1),
-	}
-
-	benchEC2QueryBuild(b, "AuthorizeSecurityGroupEgress", params)
-}
-
-func BenchmarkEC2QueryBuild_Simple_ec2AttachNetworkInterface(b *testing.B) {
-	params := &ec2.AttachNetworkInterfaceInput{
-		DeviceIndex:        aws.Int64(1),         // Required
-		InstanceId:         aws.String("String"), // Required
-		NetworkInterfaceId: aws.String("String"), // Required
-		DryRun:             aws.Bool(true),
-	}
-
-	benchEC2QueryBuild(b, "AttachNetworkInterface", params)
-}
-
-func benchEC2QueryBuild(b *testing.B, opName string, params interface{}) {
-	svc := awstesting.NewClient()
-	svc.ServiceName = "ec2"
-	svc.APIVersion = "2015-04-15"
-
-	for i := 0; i < b.N; i++ {
-		r := svc.NewRequest(&request.Operation{
-			Name:       opName,
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		}, params, nil)
-		ec2query.Build(r)
-		if r.Error != nil {
-			b.Fatal("Unexpected error", r.Error)
-		}
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/ec2query/build_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/ec2query/build_test.go
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/ec2query/unmarshal_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/ec2query/unmarshal_test.go
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/query/build_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/query/build_test.go
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go
@@ -1,33 +0,0 @@
-package query
-
-import (
-	"encoding/xml"
-	"io"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-type xmlErrorResponse struct {
-	XMLName   xml.Name `xml:"ErrorResponse"`
-	Code      string   `xml:"Error>Code"`
-	Message   string   `xml:"Error>Message"`
-	RequestID string   `xml:"RequestId"`
-}
-
-// UnmarshalError unmarshals an error response for an AWS Query service.
-func UnmarshalError(r *request.Request) {
-	defer r.HTTPResponse.Body.Close()
-
-	resp := &xmlErrorResponse{}
-	err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
-	if err != nil && err != io.EOF {
-		r.Error = awserr.New("SerializationError", "failed to decode query XML error response", err)
-	} else {
-		r.Error = awserr.NewRequestFailure(
-			awserr.New(resp.Code, resp.Message, nil),
-			r.HTTPResponse.StatusCode,
-			resp.RequestID,
-		)
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_test.go
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/rest/payload.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/rest/payload.go
@@ -1,45 +0,0 @@
-package rest
-
-import "reflect"
-
-// PayloadMember returns the payload field member of i if there is one, or nil.
-func PayloadMember(i interface{}) interface{} {
-	if i == nil {
-		return nil
-	}
-
-	v := reflect.ValueOf(i).Elem()
-	if !v.IsValid() {
-		return nil
-	}
-	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
-		if payloadName := field.Tag.Get("payload"); payloadName != "" {
-			field, _ := v.Type().FieldByName(payloadName)
-			if field.Tag.Get("type") != "structure" {
-				return nil
-			}
-
-			payload := v.FieldByName(payloadName)
-			if payload.IsValid() || (payload.Kind() == reflect.Ptr && !payload.IsNil()) {
-				return payload.Interface()
-			}
-		}
-	}
-	return nil
-}
-
-// PayloadType returns the type of a payload field member of i if there is one, or "".
-func PayloadType(i interface{}) string {
-	v := reflect.Indirect(reflect.ValueOf(i))
-	if !v.IsValid() {
-		return ""
-	}
-	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
-		if payloadName := field.Tag.Get("payload"); payloadName != "" {
-			if member, ok := v.Type().FieldByName(payloadName); ok {
-				return member.Tag.Get("type")
-			}
-		}
-	}
-	return ""
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go
@@ -1,260 +0,0 @@
-package xmlutil
-
-import (
-	"encoding/base64"
-	"encoding/xml"
-	"fmt"
-	"io"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// UnmarshalXML deserializes an xml.Decoder into the container v. V
-// needs to match the shape of the XML expected to be decoded.
-// If the shape doesn't match unmarshaling will fail.
-func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
-	n, _ := XMLToStruct(d, nil)
-	if n.Children != nil {
-		for _, root := range n.Children {
-			for _, c := range root {
-				if wrappedChild, ok := c.Children[wrapper]; ok {
-					c = wrappedChild[0] // pull out wrapped element
-				}
-
-				err := parse(reflect.ValueOf(v), c, "")
-				if err != nil {
-					if err == io.EOF {
-						return nil
-					}
-					return err
-				}
-			}
-		}
-		return nil
-	}
-	return nil
-}
-
-// parse deserializes any value from the XMLNode. The type tag is used to infer the type, or reflect
-// will be used to determine the type from r.
-func parse(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	rtype := r.Type()
-	if rtype.Kind() == reflect.Ptr {
-		rtype = rtype.Elem() // check kind of actual element type
-	}
-
-	t := tag.Get("type")
-	if t == "" {
-		switch rtype.Kind() {
-		case reflect.Struct:
-			t = "structure"
-		case reflect.Slice:
-			t = "list"
-		case reflect.Map:
-			t = "map"
-		}
-	}
-
-	switch t {
-	case "structure":
-		if field, ok := rtype.FieldByName("SDKShapeTraits"); ok {
-			tag = field.Tag
-		}
-		return parseStruct(r, node, tag)
-	case "list":
-		return parseList(r, node, tag)
-	case "map":
-		return parseMap(r, node, tag)
-	default:
-		return parseScalar(r, node, tag)
-	}
-}
-
-// parseStruct deserializes a structure and its fields from an XMLNode. Any nested
-// types in the structure will also be deserialized.
-func parseStruct(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	t := r.Type()
-	if r.Kind() == reflect.Ptr {
-		if r.IsNil() { // create the structure if it's nil
-			s := reflect.New(r.Type().Elem())
-			r.Set(s)
-			r = s
-		}
-
-		r = r.Elem()
-		t = t.Elem()
-	}
-
-	// unwrap any payloads
-	if payload := tag.Get("payload"); payload != "" {
-		field, _ := t.FieldByName(payload)
-		return parseStruct(r.FieldByName(payload), node, field.Tag)
-	}
-
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
-		if c := field.Name[0:1]; strings.ToLower(c) == c {
-			continue // ignore unexported fields
-		}
-
-		// figure out what this field is called
-		name := field.Name
-		if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {
-			name = field.Tag.Get("locationNameList")
-		} else if locName := field.Tag.Get("locationName"); locName != "" {
-			name = locName
-		}
-
-		// try to find the field by name in elements
-		elems := node.Children[name]
-
-		if elems == nil { // try to find the field in attributes
-			for _, a := range node.Attr {
-				if name == a.Name.Local {
-					// turn this into a text node for de-serializing
-					elems = []*XMLNode{{Text: a.Value}}
-				}
-			}
-		}
-
-		member := r.FieldByName(field.Name)
-		for _, elem := range elems {
-			err := parse(member, elem, field.Tag)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// parseList deserializes a list of values from an XML node. Each list entry
-// will also be deserialized.
-func parseList(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	t := r.Type()
-
-	if tag.Get("flattened") == "" { // look at all item entries
-		mname := "member"
-		if name := tag.Get("locationNameList"); name != "" {
-			mname = name
-		}
-
-		if Children, ok := node.Children[mname]; ok {
-			if r.IsNil() {
-				r.Set(reflect.MakeSlice(t, len(Children), len(Children)))
-			}
-
-			for i, c := range Children {
-				err := parse(r.Index(i), c, "")
-				if err != nil {
-					return err
-				}
-			}
-		}
-	} else { // flattened list means this is a single element
-		if r.IsNil() {
-			r.Set(reflect.MakeSlice(t, 0, 0))
-		}
-
-		childR := reflect.Zero(t.Elem())
-		r.Set(reflect.Append(r, childR))
-		err := parse(r.Index(r.Len()-1), node, "")
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// parseMap deserializes a map from an XMLNode. The direct children of the XMLNode
-// will also be deserialized as map entries.
-func parseMap(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	if r.IsNil() {
-		r.Set(reflect.MakeMap(r.Type()))
-	}
-
-	if tag.Get("flattened") == "" { // look at all child entries
-		for _, entry := range node.Children["entry"] {
-			parseMapEntry(r, entry, tag)
-		}
-	} else { // this element is itself an entry
-		parseMapEntry(r, node, tag)
-	}
-
-	return nil
-}
-
-// parseMapEntry deserializes a map entry from a XML node.
-func parseMapEntry(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	kname, vname := "key", "value"
-	if n := tag.Get("locationNameKey"); n != "" {
-		kname = n
-	}
-	if n := tag.Get("locationNameValue"); n != "" {
-		vname = n
-	}
-
-	keys, ok := node.Children[kname]
-	values := node.Children[vname]
-	if ok {
-		for i, key := range keys {
-			keyR := reflect.ValueOf(key.Text)
-			value := values[i]
-			valueR := reflect.New(r.Type().Elem()).Elem()
-
-			parse(valueR, value, "")
-			r.SetMapIndex(keyR, valueR)
-		}
-	}
-	return nil
-}
-
-// parseScaller deserializes an XMLNode value into a concrete type based on the
-// interface type of r.
-//
-// Error is returned if the deserialization fails due to invalid type conversion,
-// or unsupported interface type.
-func parseScalar(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	switch r.Interface().(type) {
-	case *string:
-		r.Set(reflect.ValueOf(&node.Text))
-		return nil
-	case []byte:
-		b, err := base64.StdEncoding.DecodeString(node.Text)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(b))
-	case *bool:
-		v, err := strconv.ParseBool(node.Text)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(&v))
-	case *int64:
-		v, err := strconv.ParseInt(node.Text, 10, 64)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(&v))
-	case *float64:
-		v, err := strconv.ParseFloat(node.Text, 64)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(&v))
-	case *time.Time:
-		const ISO8601UTC = "2006-01-02T15:04:05Z"
-		t, err := time.Parse(ISO8601UTC, node.Text)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(&t))
-	default:
-		return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type())
-	}
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go
@@ -1,105 +0,0 @@
-package xmlutil
-
-import (
-	"encoding/xml"
-	"io"
-	"sort"
-)
-
-// A XMLNode contains the values to be encoded or decoded.
-type XMLNode struct {
-	Name     xml.Name              `json:",omitempty"`
-	Children map[string][]*XMLNode `json:",omitempty"`
-	Text     string                `json:",omitempty"`
-	Attr     []xml.Attr            `json:",omitempty"`
-}
-
-// NewXMLElement returns a pointer to a new XMLNode initialized to default values.
-func NewXMLElement(name xml.Name) *XMLNode {
-	return &XMLNode{
-		Name:     name,
-		Children: map[string][]*XMLNode{},
-		Attr:     []xml.Attr{},
-	}
-}
-
-// AddChild adds child to the XMLNode.
-func (n *XMLNode) AddChild(child *XMLNode) {
-	if _, ok := n.Children[child.Name.Local]; !ok {
-		n.Children[child.Name.Local] = []*XMLNode{}
-	}
-	n.Children[child.Name.Local] = append(n.Children[child.Name.Local], child)
-}
-
-// XMLToStruct converts a xml.Decoder stream to XMLNode with nested values.
-func XMLToStruct(d *xml.Decoder, s *xml.StartElement) (*XMLNode, error) {
-	out := &XMLNode{}
-	for {
-		tok, err := d.Token()
-		if tok == nil || err == io.EOF {
-			break
-		}
-		if err != nil {
-			return out, err
-		}
-
-		switch typed := tok.(type) {
-		case xml.CharData:
-			out.Text = string(typed.Copy())
-		case xml.StartElement:
-			el := typed.Copy()
-			out.Attr = el.Attr
-			if out.Children == nil {
-				out.Children = map[string][]*XMLNode{}
-			}
-
-			name := typed.Name.Local
-			slice := out.Children[name]
-			if slice == nil {
-				slice = []*XMLNode{}
-			}
-			node, e := XMLToStruct(d, &el)
-			if e != nil {
-				return out, e
-			}
-			node.Name = typed.Name
-			slice = append(slice, node)
-			out.Children[name] = slice
-		case xml.EndElement:
-			if s != nil && s.Name.Local == typed.Name.Local { // matching end token
-				return out, nil
-			}
-		}
-	}
-	return out, nil
-}
-
-// StructToXML writes an XMLNode to a xml.Encoder as tokens.
-func StructToXML(e *xml.Encoder, node *XMLNode, sorted bool) error {
-	e.EncodeToken(xml.StartElement{Name: node.Name, Attr: node.Attr})
-
-	if node.Text != "" {
-		e.EncodeToken(xml.CharData([]byte(node.Text)))
-	} else if sorted {
-		sortedNames := []string{}
-		for k := range node.Children {
-			sortedNames = append(sortedNames, k)
-		}
-		sort.Strings(sortedNames)
-
-		for _, k := range sortedNames {
-			for _, v := range node.Children[k] {
-				StructToXML(e, v, sorted)
-			}
-		}
-	} else {
-		for _, c := range node.Children {
-			for _, v := range c {
-				StructToXML(e, v, sorted)
-			}
-		}
-	}
-
-	e.EncodeToken(xml.EndElement{Name: node.Name})
-	return e.Flush()
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/signer/v4/functional_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/signer/v4/functional_test.go
@@ -1,42 +0,0 @@
-package v4_test
-
-import (
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/awstesting/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-)
-
-func TestPresignHandler(t *testing.T) {
-	svc := s3.New(unit.Session)
-	req, _ := svc.PutObjectRequest(&s3.PutObjectInput{
-		Bucket:             aws.String("bucket"),
-		Key:                aws.String("key"),
-		ContentDisposition: aws.String("a+b c$d"),
-		ACL:                aws.String("public-read"),
-	})
-	req.Time = time.Unix(0, 0)
-	urlstr, err := req.Presign(5 * time.Minute)
-
-	assert.NoError(t, err)
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-acl"
-	expectedSig := "7edcb4e3a1bf12f4989018d75acbe3a7f03df24bd6f3112602d59fc551f0e4e2"
-	expectedCred := "AKID/19700101/mock-region/s3/aws4_request"
-
-	u, _ := url.Parse(urlstr)
-	urlQ := u.Query()
-	assert.Equal(t, expectedSig, urlQ.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, urlQ.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, urlQ.Get("X-Amz-Date"))
-	assert.Equal(t, "300", urlQ.Get("X-Amz-Expires"))
-
-	assert.NotContains(t, urlstr, "+") // + encoded as %20
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/signer/v4/v4.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/signer/v4/v4.go
@@ -1,365 +0,0 @@
-// Package v4 implements signing for AWS V4 signer
-package v4
-
-import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/protocol/rest"
-)
-
-const (
-	authHeaderPrefix = "AWS4-HMAC-SHA256"
-	timeFormat       = "20060102T150405Z"
-	shortTimeFormat  = "20060102"
-)
-
-var ignoredHeaders = map[string]bool{
-	"Authorization":  true,
-	"Content-Type":   true,
-	"Content-Length": true,
-	"User-Agent":     true,
-}
-
-type signer struct {
-	Request     *http.Request
-	Time        time.Time
-	ExpireTime  time.Duration
-	ServiceName string
-	Region      string
-	CredValues  credentials.Value
-	Credentials *credentials.Credentials
-	Query       url.Values
-	Body        io.ReadSeeker
-	Debug       aws.LogLevelType
-	Logger      aws.Logger
-
-	isPresign          bool
-	formattedTime      string
-	formattedShortTime string
-
-	signedHeaders    string
-	canonicalHeaders string
-	canonicalString  string
-	credentialString string
-	stringToSign     string
-	signature        string
-	authorization    string
-}
-
-// Sign requests with signature version 4.
-//
-// Will sign the requests with the service config's Credentials object
-// Signing is skipped if the credentials is the credentials.AnonymousCredentials
-// object.
-func Sign(req *request.Request) {
-	// If the request does not need to be signed ignore the signing of the
-	// request if the AnonymousCredentials object is used.
-	if req.Config.Credentials == credentials.AnonymousCredentials {
-		return
-	}
-
-	region := req.ClientInfo.SigningRegion
-	if region == "" {
-		region = aws.StringValue(req.Config.Region)
-	}
-
-	name := req.ClientInfo.SigningName
-	if name == "" {
-		name = req.ClientInfo.ServiceName
-	}
-
-	s := signer{
-		Request:     req.HTTPRequest,
-		Time:        req.Time,
-		ExpireTime:  req.ExpireTime,
-		Query:       req.HTTPRequest.URL.Query(),
-		Body:        req.Body,
-		ServiceName: name,
-		Region:      region,
-		Credentials: req.Config.Credentials,
-		Debug:       req.Config.LogLevel.Value(),
-		Logger:      req.Config.Logger,
-	}
-
-	req.Error = s.sign()
-}
-
-func (v4 *signer) sign() error {
-	if v4.ExpireTime != 0 {
-		v4.isPresign = true
-	}
-
-	if v4.isRequestSigned() {
-		if !v4.Credentials.IsExpired() {
-			// If the request is already signed, and the credentials have not
-			// expired yet ignore the signing request.
-			return nil
-		}
-
-		// The credentials have expired for this request. The current signing
-		// is invalid, and needs to be request because the request will fail.
-		if v4.isPresign {
-			v4.removePresign()
-			// Update the request's query string to ensure the values stays in
-			// sync in the case retrieving the new credentials fails.
-			v4.Request.URL.RawQuery = v4.Query.Encode()
-		}
-	}
-
-	var err error
-	v4.CredValues, err = v4.Credentials.Get()
-	if err != nil {
-		return err
-	}
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-Algorithm", authHeaderPrefix)
-		if v4.CredValues.SessionToken != "" {
-			v4.Query.Set("X-Amz-Security-Token", v4.CredValues.SessionToken)
-		} else {
-			v4.Query.Del("X-Amz-Security-Token")
-		}
-	} else if v4.CredValues.SessionToken != "" {
-		v4.Request.Header.Set("X-Amz-Security-Token", v4.CredValues.SessionToken)
-	}
-
-	v4.build()
-
-	if v4.Debug.Matches(aws.LogDebugWithSigning) {
-		v4.logSigningInfo()
-	}
-
-	return nil
-}
-
-const logSignInfoMsg = `DEBUG: Request Signiture:
---[ CANONICAL STRING  ]-----------------------------
-%s
---[ STRING TO SIGN ]--------------------------------
-%s%s
-----------------------------------------------------`
-const logSignedURLMsg = `
---[ SIGNED URL ]------------------------------------
-%s`
-
-func (v4 *signer) logSigningInfo() {
-	signedURLMsg := ""
-	if v4.isPresign {
-		signedURLMsg = fmt.Sprintf(logSignedURLMsg, v4.Request.URL.String())
-	}
-	msg := fmt.Sprintf(logSignInfoMsg, v4.canonicalString, v4.stringToSign, signedURLMsg)
-	v4.Logger.Log(msg)
-}
-
-func (v4 *signer) build() {
-	v4.buildTime()             // no depends
-	v4.buildCredentialString() // no depends
-	if v4.isPresign {
-		v4.buildQuery() // no depends
-	}
-	v4.buildCanonicalHeaders() // depends on cred string
-	v4.buildCanonicalString()  // depends on canon headers / signed headers
-	v4.buildStringToSign()     // depends on canon string
-	v4.buildSignature()        // depends on string to sign
-
-	if v4.isPresign {
-		v4.Request.URL.RawQuery += "&X-Amz-Signature=" + v4.signature
-	} else {
-		parts := []string{
-			authHeaderPrefix + " Credential=" + v4.CredValues.AccessKeyID + "/" + v4.credentialString,
-			"SignedHeaders=" + v4.signedHeaders,
-			"Signature=" + v4.signature,
-		}
-		v4.Request.Header.Set("Authorization", strings.Join(parts, ", "))
-	}
-}
-
-func (v4 *signer) buildTime() {
-	v4.formattedTime = v4.Time.UTC().Format(timeFormat)
-	v4.formattedShortTime = v4.Time.UTC().Format(shortTimeFormat)
-
-	if v4.isPresign {
-		duration := int64(v4.ExpireTime / time.Second)
-		v4.Query.Set("X-Amz-Date", v4.formattedTime)
-		v4.Query.Set("X-Amz-Expires", strconv.FormatInt(duration, 10))
-	} else {
-		v4.Request.Header.Set("X-Amz-Date", v4.formattedTime)
-	}
-}
-
-func (v4 *signer) buildCredentialString() {
-	v4.credentialString = strings.Join([]string{
-		v4.formattedShortTime,
-		v4.Region,
-		v4.ServiceName,
-		"aws4_request",
-	}, "/")
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-Credential", v4.CredValues.AccessKeyID+"/"+v4.credentialString)
-	}
-}
-
-func (v4 *signer) buildQuery() {
-	for k, h := range v4.Request.Header {
-		if strings.HasPrefix(http.CanonicalHeaderKey(k), "X-Amz-") {
-			continue // never hoist x-amz-* headers, they must be signed
-		}
-		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
-			continue // never hoist ignored headers
-		}
-
-		v4.Request.Header.Del(k)
-		v4.Query.Del(k)
-		for _, v := range h {
-			v4.Query.Add(k, v)
-		}
-	}
-}
-
-func (v4 *signer) buildCanonicalHeaders() {
-	var headers []string
-	headers = append(headers, "host")
-	for k := range v4.Request.Header {
-		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
-			continue // ignored header
-		}
-		headers = append(headers, strings.ToLower(k))
-	}
-	sort.Strings(headers)
-
-	v4.signedHeaders = strings.Join(headers, ";")
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-SignedHeaders", v4.signedHeaders)
-	}
-
-	headerValues := make([]string, len(headers))
-	for i, k := range headers {
-		if k == "host" {
-			headerValues[i] = "host:" + v4.Request.URL.Host
-		} else {
-			headerValues[i] = k + ":" +
-				strings.Join(v4.Request.Header[http.CanonicalHeaderKey(k)], ",")
-		}
-	}
-
-	v4.canonicalHeaders = strings.Join(headerValues, "\n")
-}
-
-func (v4 *signer) buildCanonicalString() {
-	v4.Request.URL.RawQuery = strings.Replace(v4.Query.Encode(), "+", "%20", -1)
-	uri := v4.Request.URL.Opaque
-	if uri != "" {
-		uri = "/" + strings.Join(strings.Split(uri, "/")[3:], "/")
-	} else {
-		uri = v4.Request.URL.Path
-	}
-	if uri == "" {
-		uri = "/"
-	}
-
-	if v4.ServiceName != "s3" {
-		uri = rest.EscapePath(uri, false)
-	}
-
-	v4.canonicalString = strings.Join([]string{
-		v4.Request.Method,
-		uri,
-		v4.Request.URL.RawQuery,
-		v4.canonicalHeaders + "\n",
-		v4.signedHeaders,
-		v4.bodyDigest(),
-	}, "\n")
-}
-
-func (v4 *signer) buildStringToSign() {
-	v4.stringToSign = strings.Join([]string{
-		authHeaderPrefix,
-		v4.formattedTime,
-		v4.credentialString,
-		hex.EncodeToString(makeSha256([]byte(v4.canonicalString))),
-	}, "\n")
-}
-
-func (v4 *signer) buildSignature() {
-	secret := v4.CredValues.SecretAccessKey
-	date := makeHmac([]byte("AWS4"+secret), []byte(v4.formattedShortTime))
-	region := makeHmac(date, []byte(v4.Region))
-	service := makeHmac(region, []byte(v4.ServiceName))
-	credentials := makeHmac(service, []byte("aws4_request"))
-	signature := makeHmac(credentials, []byte(v4.stringToSign))
-	v4.signature = hex.EncodeToString(signature)
-}
-
-func (v4 *signer) bodyDigest() string {
-	hash := v4.Request.Header.Get("X-Amz-Content-Sha256")
-	if hash == "" {
-		if v4.isPresign && v4.ServiceName == "s3" {
-			hash = "UNSIGNED-PAYLOAD"
-		} else if v4.Body == nil {
-			hash = hex.EncodeToString(makeSha256([]byte{}))
-		} else {
-			hash = hex.EncodeToString(makeSha256Reader(v4.Body))
-		}
-		v4.Request.Header.Add("X-Amz-Content-Sha256", hash)
-	}
-	return hash
-}
-
-// isRequestSigned returns if the request is currently signed or presigned
-func (v4 *signer) isRequestSigned() bool {
-	if v4.isPresign && v4.Query.Get("X-Amz-Signature") != "" {
-		return true
-	}
-	if v4.Request.Header.Get("Authorization") != "" {
-		return true
-	}
-
-	return false
-}
-
-// unsign removes signing flags for both signed and presigned requests.
-func (v4 *signer) removePresign() {
-	v4.Query.Del("X-Amz-Algorithm")
-	v4.Query.Del("X-Amz-Signature")
-	v4.Query.Del("X-Amz-Security-Token")
-	v4.Query.Del("X-Amz-Date")
-	v4.Query.Del("X-Amz-Expires")
-	v4.Query.Del("X-Amz-Credential")
-	v4.Query.Del("X-Amz-SignedHeaders")
-}
-
-func makeHmac(key []byte, data []byte) []byte {
-	hash := hmac.New(sha256.New, key)
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-func makeSha256(data []byte) []byte {
-	hash := sha256.New()
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-func makeSha256Reader(reader io.ReadSeeker) []byte {
-	hash := sha256.New()
-	start, _ := reader.Seek(0, 1)
-	defer reader.Seek(start, 0)
-
-	io.Copy(hash, reader)
-	return hash.Sum(nil)
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/signer/v4/v4_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/signer/v4/v4_test.go
@@ -1,252 +0,0 @@
-package v4
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-)
-
-func buildSigner(serviceName string, region string, signTime time.Time, expireTime time.Duration, body string) signer {
-	endpoint := "https://" + serviceName + "." + region + ".amazonaws.com"
-	reader := strings.NewReader(body)
-	req, _ := http.NewRequest("POST", endpoint, reader)
-	req.URL.Opaque = "//example.org/bucket/key-._~,!@#$%^&*()"
-	req.Header.Add("X-Amz-Target", "prefix.Operation")
-	req.Header.Add("Content-Type", "application/x-amz-json-1.0")
-	req.Header.Add("Content-Length", string(len(body)))
-	req.Header.Add("X-Amz-Meta-Other-Header", "some-value=!@#$%^&* (+)")
-
-	return signer{
-		Request:     req,
-		Time:        signTime,
-		ExpireTime:  expireTime,
-		Query:       req.URL.Query(),
-		Body:        reader,
-		ServiceName: serviceName,
-		Region:      region,
-		Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-	}
-}
-
-func removeWS(text string) string {
-	text = strings.Replace(text, " ", "", -1)
-	text = strings.Replace(text, "\n", "", -1)
-	text = strings.Replace(text, "\t", "", -1)
-	return text
-}
-
-func assertEqual(t *testing.T, expected, given string) {
-	if removeWS(expected) != removeWS(given) {
-		t.Errorf("\nExpected: %s\nGiven:    %s", expected, given)
-	}
-}
-
-func TestPresignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 300*time.Second, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-meta-other-header;x-amz-target"
-	expectedSig := "5eeedebf6f995145ce56daa02902d10485246d3defb34f97b973c1f40ab82d36"
-	expectedCred := "AKID/19700101/us-east-1/dynamodb/aws4_request"
-
-	q := signer.Request.URL.Query()
-	assert.Equal(t, expectedSig, q.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, q.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, q.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 0, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedSig := "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/dynamodb/aws4_request, SignedHeaders=host;x-amz-date;x-amz-meta-other-header;x-amz-security-token;x-amz-target, Signature=69ada33fec48180dab153576e4dd80c4e04124f80dda3eccfed8a67c2b91ed5e"
-
-	q := signer.Request.Header
-	assert.Equal(t, expectedSig, q.Get("Authorization"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignEmptyBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "")
-	signer.Body = nil
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", hash)
-}
-
-func TestSignBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-}
-
-func TestSignSeekedBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "   hello")
-	signer.Body.Read(make([]byte, 3)) // consume first 3 bytes so body is now "hello"
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-
-	start, _ := signer.Body.Seek(0, 1)
-	assert.Equal(t, int64(3), start)
-}
-
-func TestPresignEmptyBodyS3(t *testing.T) {
-	signer := buildSigner("s3", "us-east-1", time.Now(), 5*time.Minute, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "UNSIGNED-PAYLOAD", hash)
-}
-
-func TestSignPrecomputedBodyChecksum(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.Request.Header.Set("X-Amz-Content-Sha256", "PRECOMPUTED")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "PRECOMPUTED", hash)
-}
-
-func TestAnonymousCredentials(t *testing.T) {
-	svc := awstesting.NewClient(&aws.Config{Credentials: credentials.AnonymousCredentials})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-
-	urlQ := r.HTTPRequest.URL.Query()
-	assert.Empty(t, urlQ.Get("X-Amz-Signature"))
-	assert.Empty(t, urlQ.Get("X-Amz-Credential"))
-	assert.Empty(t, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Empty(t, urlQ.Get("X-Amz-Date"))
-
-	hQ := r.HTTPRequest.Header
-	assert.Empty(t, hQ.Get("Authorization"))
-	assert.Empty(t, hQ.Get("X-Amz-Date"))
-}
-
-func TestIgnoreResignRequestWithValidCreds(t *testing.T) {
-	svc := awstesting.NewClient(&aws.Config{
-		Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-		Region:      aws.String("us-west-2"),
-	})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("Authorization")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestIgnorePreResignRequestWithValidCreds(t *testing.T) {
-	svc := awstesting.NewClient(&aws.Config{
-		Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-		Region:      aws.String("us-west-2"),
-	})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("X-Amz-Signature")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("X-Amz-Signature"))
-}
-
-func TestResignRequestExpiredCreds(t *testing.T) {
-	creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION")
-	svc := awstesting.NewClient(&aws.Config{Credentials: creds})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-	querySig := r.HTTPRequest.Header.Get("Authorization")
-
-	creds.Expire()
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestPreResignRequestExpiredCreds(t *testing.T) {
-	provider := &credentials.StaticProvider{Value: credentials.Value{
-		AccessKeyID:     "AKID",
-		SecretAccessKey: "SECRET",
-		SessionToken:    "SESSION",
-	}}
-	creds := credentials.NewCredentials(provider)
-	svc := awstesting.NewClient(&aws.Config{Credentials: creds})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	querySig := r.HTTPRequest.URL.Query().Get("X-Amz-Signature")
-
-	creds.Expire()
-	r.Time = time.Now().Add(time.Hour * 48)
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.URL.Query().Get("X-Amz-Signature"))
-}
-
-func BenchmarkPresignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 300*time.Second, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}
-
-func BenchmarkSignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/waiter/waiter_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/private/waiter/waiter_test.go
@@ -1,391 +0,0 @@
-package waiter_test
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-	"github.com/aws/aws-sdk-go/private/waiter"
-)
-
-type mockClient struct {
-	*client.Client
-}
-type MockInput struct{}
-type MockOutput struct {
-	States []*MockState
-}
-type MockState struct {
-	State *string
-}
-
-func (c *mockClient) MockRequest(input *MockInput) (*request.Request, *MockOutput) {
-	op := &request.Operation{
-		Name:       "Mock",
-		HTTPMethod: "POST",
-		HTTPPath:   "/",
-	}
-
-	if input == nil {
-		input = &MockInput{}
-	}
-
-	output := &MockOutput{}
-	req := c.NewRequest(op, input, output)
-	req.Data = output
-	return req, output
-}
-
-func TestWaiterPathAll(t *testing.T) {
-	svc := &mockClient{Client: awstesting.NewClient(&aws.Config{
-		Region: aws.String("mock-region"),
-	})}
-	svc.Handlers.Send.Clear() // mock sending
-	svc.Handlers.Unmarshal.Clear()
-	svc.Handlers.UnmarshalMeta.Clear()
-	svc.Handlers.ValidateResponse.Clear()
-
-	reqNum := 0
-	resps := []*MockOutput{
-		{ // Request 1
-			States: []*MockState{
-				{State: aws.String("pending")},
-				{State: aws.String("pending")},
-			},
-		},
-		{ // Request 2
-			States: []*MockState{
-				{State: aws.String("running")},
-				{State: aws.String("pending")},
-			},
-		},
-		{ // Request 3
-			States: []*MockState{
-				{State: aws.String("running")},
-				{State: aws.String("running")},
-			},
-		},
-	}
-
-	numBuiltReq := 0
-	svc.Handlers.Build.PushBack(func(r *request.Request) {
-		numBuiltReq++
-	})
-	svc.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		if reqNum >= len(resps) {
-			assert.Fail(t, "too many polling requests made")
-			return
-		}
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	waiterCfg := waiter.Config{
-		Operation:   "Mock",
-		Delay:       0,
-		MaxAttempts: 10,
-		Acceptors: []waiter.WaitAcceptor{
-			{
-				State:    "success",
-				Matcher:  "pathAll",
-				Argument: "States[].State",
-				Expected: "running",
-			},
-		},
-	}
-	w := waiter.Waiter{
-		Client: svc,
-		Input:  &MockInput{},
-		Config: waiterCfg,
-	}
-
-	err := w.Wait()
-	assert.NoError(t, err)
-	assert.Equal(t, 3, numBuiltReq)
-	assert.Equal(t, 3, reqNum)
-}
-
-func TestWaiterPath(t *testing.T) {
-	svc := &mockClient{Client: awstesting.NewClient(&aws.Config{
-		Region: aws.String("mock-region"),
-	})}
-	svc.Handlers.Send.Clear() // mock sending
-	svc.Handlers.Unmarshal.Clear()
-	svc.Handlers.UnmarshalMeta.Clear()
-	svc.Handlers.ValidateResponse.Clear()
-
-	reqNum := 0
-	resps := []*MockOutput{
-		{ // Request 1
-			States: []*MockState{
-				{State: aws.String("pending")},
-				{State: aws.String("pending")},
-			},
-		},
-		{ // Request 2
-			States: []*MockState{
-				{State: aws.String("running")},
-				{State: aws.String("pending")},
-			},
-		},
-		{ // Request 3
-			States: []*MockState{
-				{State: aws.String("running")},
-				{State: aws.String("running")},
-			},
-		},
-	}
-
-	numBuiltReq := 0
-	svc.Handlers.Build.PushBack(func(r *request.Request) {
-		numBuiltReq++
-	})
-	svc.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		if reqNum >= len(resps) {
-			assert.Fail(t, "too many polling requests made")
-			return
-		}
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	waiterCfg := waiter.Config{
-		Operation:   "Mock",
-		Delay:       0,
-		MaxAttempts: 10,
-		Acceptors: []waiter.WaitAcceptor{
-			{
-				State:    "success",
-				Matcher:  "path",
-				Argument: "States[].State",
-				Expected: "running",
-			},
-		},
-	}
-	w := waiter.Waiter{
-		Client: svc,
-		Input:  &MockInput{},
-		Config: waiterCfg,
-	}
-
-	err := w.Wait()
-	assert.NoError(t, err)
-	assert.Equal(t, 3, numBuiltReq)
-	assert.Equal(t, 3, reqNum)
-}
-
-func TestWaiterFailure(t *testing.T) {
-	svc := &mockClient{Client: awstesting.NewClient(&aws.Config{
-		Region: aws.String("mock-region"),
-	})}
-	svc.Handlers.Send.Clear() // mock sending
-	svc.Handlers.Unmarshal.Clear()
-	svc.Handlers.UnmarshalMeta.Clear()
-	svc.Handlers.ValidateResponse.Clear()
-
-	reqNum := 0
-	resps := []*MockOutput{
-		{ // Request 1
-			States: []*MockState{
-				{State: aws.String("pending")},
-				{State: aws.String("pending")},
-			},
-		},
-		{ // Request 2
-			States: []*MockState{
-				{State: aws.String("running")},
-				{State: aws.String("pending")},
-			},
-		},
-		{ // Request 3
-			States: []*MockState{
-				{State: aws.String("running")},
-				{State: aws.String("stopping")},
-			},
-		},
-	}
-
-	numBuiltReq := 0
-	svc.Handlers.Build.PushBack(func(r *request.Request) {
-		numBuiltReq++
-	})
-	svc.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		if reqNum >= len(resps) {
-			assert.Fail(t, "too many polling requests made")
-			return
-		}
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	waiterCfg := waiter.Config{
-		Operation:   "Mock",
-		Delay:       0,
-		MaxAttempts: 10,
-		Acceptors: []waiter.WaitAcceptor{
-			{
-				State:    "success",
-				Matcher:  "pathAll",
-				Argument: "States[].State",
-				Expected: "running",
-			},
-			{
-				State:    "failure",
-				Matcher:  "pathAny",
-				Argument: "States[].State",
-				Expected: "stopping",
-			},
-		},
-	}
-	w := waiter.Waiter{
-		Client: svc,
-		Input:  &MockInput{},
-		Config: waiterCfg,
-	}
-
-	err := w.Wait().(awserr.Error)
-	assert.Error(t, err)
-	assert.Equal(t, "ResourceNotReady", err.Code())
-	assert.Equal(t, "failed waiting for successful resource state", err.Message())
-	assert.Equal(t, 3, numBuiltReq)
-	assert.Equal(t, 3, reqNum)
-}
-
-func TestWaiterError(t *testing.T) {
-	svc := &mockClient{Client: awstesting.NewClient(&aws.Config{
-		Region: aws.String("mock-region"),
-	})}
-	svc.Handlers.Send.Clear() // mock sending
-	svc.Handlers.Unmarshal.Clear()
-	svc.Handlers.UnmarshalMeta.Clear()
-	svc.Handlers.ValidateResponse.Clear()
-
-	reqNum := 0
-	resps := []*MockOutput{
-		{ // Request 1
-			States: []*MockState{
-				{State: aws.String("pending")},
-				{State: aws.String("pending")},
-			},
-		},
-		{ // Request 2, error case
-		},
-		{ // Request 3
-			States: []*MockState{
-				{State: aws.String("running")},
-				{State: aws.String("running")},
-			},
-		},
-	}
-
-	numBuiltReq := 0
-	svc.Handlers.Build.PushBack(func(r *request.Request) {
-		numBuiltReq++
-	})
-	svc.Handlers.Send.PushBack(func(r *request.Request) {
-		if reqNum == 1 {
-			r.Error = awserr.New("MockException", "mock exception message", nil)
-			r.HTTPResponse = &http.Response{
-				StatusCode: 400,
-				Status:     http.StatusText(400),
-				Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
-			}
-			reqNum++
-		}
-	})
-	svc.Handlers.Unmarshal.PushBack(func(r *request.Request) {
-		if reqNum >= len(resps) {
-			assert.Fail(t, "too many polling requests made")
-			return
-		}
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	waiterCfg := waiter.Config{
-		Operation:   "Mock",
-		Delay:       0,
-		MaxAttempts: 10,
-		Acceptors: []waiter.WaitAcceptor{
-			{
-				State:    "success",
-				Matcher:  "pathAll",
-				Argument: "States[].State",
-				Expected: "running",
-			},
-			{
-				State:    "retry",
-				Matcher:  "error",
-				Argument: "",
-				Expected: "MockException",
-			},
-		},
-	}
-	w := waiter.Waiter{
-		Client: svc,
-		Input:  &MockInput{},
-		Config: waiterCfg,
-	}
-
-	err := w.Wait()
-	assert.NoError(t, err)
-	assert.Equal(t, 3, numBuiltReq)
-	assert.Equal(t, 3, reqNum)
-}
-
-func TestWaiterStatus(t *testing.T) {
-	svc := &mockClient{Client: awstesting.NewClient(&aws.Config{
-		Region: aws.String("mock-region"),
-	})}
-	svc.Handlers.Send.Clear() // mock sending
-	svc.Handlers.Unmarshal.Clear()
-	svc.Handlers.UnmarshalMeta.Clear()
-	svc.Handlers.ValidateResponse.Clear()
-
-	reqNum := 0
-	svc.Handlers.Build.PushBack(func(r *request.Request) {
-		reqNum++
-	})
-	svc.Handlers.Send.PushBack(func(r *request.Request) {
-		code := 200
-		if reqNum == 3 {
-			code = 404
-		}
-		r.HTTPResponse = &http.Response{
-			StatusCode: code,
-			Status:     http.StatusText(code),
-			Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
-		}
-	})
-
-	waiterCfg := waiter.Config{
-		Operation:   "Mock",
-		Delay:       0,
-		MaxAttempts: 10,
-		Acceptors: []waiter.WaitAcceptor{
-			{
-				State:    "success",
-				Matcher:  "status",
-				Argument: "",
-				Expected: 404,
-			},
-		},
-	}
-	w := waiter.Waiter{
-		Client: svc,
-		Input:  &MockInput{},
-		Config: waiterCfg,
-	}
-
-	err := w.Wait()
-	assert.NoError(t, err)
-	assert.Equal(t, 3, reqNum)
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/cloudwatch/api.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/cloudwatch/api.go
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/cloudwatch/examples_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/cloudwatch/examples_test.go
@@ -1,337 +0,0 @@
-// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
-
-package cloudwatch_test
-
-import (
-	"bytes"
-	"fmt"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/cloudwatch"
-)
-
-var _ time.Duration
-var _ bytes.Buffer
-
-func ExampleCloudWatch_DeleteAlarms() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.DeleteAlarmsInput{
-		AlarmNames: []*string{ // Required
-			aws.String("AlarmName"), // Required
-			// More values...
-		},
-	}
-	resp, err := svc.DeleteAlarms(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_DescribeAlarmHistory() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.DescribeAlarmHistoryInput{
-		AlarmName:       aws.String("AlarmName"),
-		EndDate:         aws.Time(time.Now()),
-		HistoryItemType: aws.String("HistoryItemType"),
-		MaxRecords:      aws.Int64(1),
-		NextToken:       aws.String("NextToken"),
-		StartDate:       aws.Time(time.Now()),
-	}
-	resp, err := svc.DescribeAlarmHistory(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_DescribeAlarms() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.DescribeAlarmsInput{
-		ActionPrefix:    aws.String("ActionPrefix"),
-		AlarmNamePrefix: aws.String("AlarmNamePrefix"),
-		AlarmNames: []*string{
-			aws.String("AlarmName"), // Required
-			// More values...
-		},
-		MaxRecords: aws.Int64(1),
-		NextToken:  aws.String("NextToken"),
-		StateValue: aws.String("StateValue"),
-	}
-	resp, err := svc.DescribeAlarms(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_DescribeAlarmsForMetric() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.DescribeAlarmsForMetricInput{
-		MetricName: aws.String("MetricName"), // Required
-		Namespace:  aws.String("Namespace"),  // Required
-		Dimensions: []*cloudwatch.Dimension{
-			{ // Required
-				Name:  aws.String("DimensionName"),  // Required
-				Value: aws.String("DimensionValue"), // Required
-			},
-			// More values...
-		},
-		Period:    aws.Int64(1),
-		Statistic: aws.String("Statistic"),
-		Unit:      aws.String("StandardUnit"),
-	}
-	resp, err := svc.DescribeAlarmsForMetric(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_DisableAlarmActions() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.DisableAlarmActionsInput{
-		AlarmNames: []*string{ // Required
-			aws.String("AlarmName"), // Required
-			// More values...
-		},
-	}
-	resp, err := svc.DisableAlarmActions(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_EnableAlarmActions() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.EnableAlarmActionsInput{
-		AlarmNames: []*string{ // Required
-			aws.String("AlarmName"), // Required
-			// More values...
-		},
-	}
-	resp, err := svc.EnableAlarmActions(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_GetMetricStatistics() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.GetMetricStatisticsInput{
-		EndTime:    aws.Time(time.Now()),     // Required
-		MetricName: aws.String("MetricName"), // Required
-		Namespace:  aws.String("Namespace"),  // Required
-		Period:     aws.Int64(1),             // Required
-		StartTime:  aws.Time(time.Now()),     // Required
-		Statistics: []*string{ // Required
-			aws.String("Statistic"), // Required
-			// More values...
-		},
-		Dimensions: []*cloudwatch.Dimension{
-			{ // Required
-				Name:  aws.String("DimensionName"),  // Required
-				Value: aws.String("DimensionValue"), // Required
-			},
-			// More values...
-		},
-		Unit: aws.String("StandardUnit"),
-	}
-	resp, err := svc.GetMetricStatistics(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_ListMetrics() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.ListMetricsInput{
-		Dimensions: []*cloudwatch.DimensionFilter{
-			{ // Required
-				Name:  aws.String("DimensionName"), // Required
-				Value: aws.String("DimensionValue"),
-			},
-			// More values...
-		},
-		MetricName: aws.String("MetricName"),
-		Namespace:  aws.String("Namespace"),
-		NextToken:  aws.String("NextToken"),
-	}
-	resp, err := svc.ListMetrics(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_PutMetricAlarm() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.PutMetricAlarmInput{
-		AlarmName:          aws.String("AlarmName"),          // Required
-		ComparisonOperator: aws.String("ComparisonOperator"), // Required
-		EvaluationPeriods:  aws.Int64(1),                     // Required
-		MetricName:         aws.String("MetricName"),         // Required
-		Namespace:          aws.String("Namespace"),          // Required
-		Period:             aws.Int64(1),                     // Required
-		Statistic:          aws.String("Statistic"),          // Required
-		Threshold:          aws.Float64(1.0),                 // Required
-		ActionsEnabled:     aws.Bool(true),
-		AlarmActions: []*string{
-			aws.String("ResourceName"), // Required
-			// More values...
-		},
-		AlarmDescription: aws.String("AlarmDescription"),
-		Dimensions: []*cloudwatch.Dimension{
-			{ // Required
-				Name:  aws.String("DimensionName"),  // Required
-				Value: aws.String("DimensionValue"), // Required
-			},
-			// More values...
-		},
-		InsufficientDataActions: []*string{
-			aws.String("ResourceName"), // Required
-			// More values...
-		},
-		OKActions: []*string{
-			aws.String("ResourceName"), // Required
-			// More values...
-		},
-		Unit: aws.String("StandardUnit"),
-	}
-	resp, err := svc.PutMetricAlarm(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_PutMetricData() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.PutMetricDataInput{
-		MetricData: []*cloudwatch.MetricDatum{ // Required
-			{ // Required
-				MetricName: aws.String("MetricName"), // Required
-				Dimensions: []*cloudwatch.Dimension{
-					{ // Required
-						Name:  aws.String("DimensionName"),  // Required
-						Value: aws.String("DimensionValue"), // Required
-					},
-					// More values...
-				},
-				StatisticValues: &cloudwatch.StatisticSet{
-					Maximum:     aws.Float64(1.0), // Required
-					Minimum:     aws.Float64(1.0), // Required
-					SampleCount: aws.Float64(1.0), // Required
-					Sum:         aws.Float64(1.0), // Required
-				},
-				Timestamp: aws.Time(time.Now()),
-				Unit:      aws.String("StandardUnit"),
-				Value:     aws.Float64(1.0),
-			},
-			// More values...
-		},
-		Namespace: aws.String("Namespace"), // Required
-	}
-	resp, err := svc.PutMetricData(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-
-func ExampleCloudWatch_SetAlarmState() {
-	svc := cloudwatch.New(session.New())
-
-	params := &cloudwatch.SetAlarmStateInput{
-		AlarmName:       aws.String("AlarmName"),   // Required
-		StateReason:     aws.String("StateReason"), // Required
-		StateValue:      aws.String("StateValue"),  // Required
-		StateReasonData: aws.String("StateReasonData"),
-	}
-	resp, err := svc.SetAlarmState(params)
-
-	if err != nil {
-		// Print the error, cast err to awserr.Error to get the Code and
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/cloudwatch/service.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/cloudwatch/service.go
@@ -1,125 +0,0 @@
-// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
-
-package cloudwatch
-
-import (
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/aws/client/metadata"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/protocol/query"
-	"github.com/aws/aws-sdk-go/private/signer/v4"
-)
-
-// This is the Amazon CloudWatch API Reference. This guide provides detailed
-// information about Amazon CloudWatch actions, data types, parameters, and
-// errors. For detailed information about Amazon CloudWatch features and their
-// associated API calls, go to the Amazon CloudWatch Developer Guide (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide).
-//
-// Amazon CloudWatch is a web service that enables you to publish, monitor,
-// and manage various metrics, as well as configure alarm actions based on data
-// from metrics. For more information about this product go to http://aws.amazon.com/cloudwatch
-// (http://aws.amazon.com/cloudwatch).
-//
-//  For information about the namespace, metric names, and dimensions that
-// other Amazon Web Services products use to send metrics to Cloudwatch, go
-// to Amazon CloudWatch Metrics, Namespaces, and Dimensions Reference (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html)
-// in the Amazon CloudWatch Developer Guide.
-//
-// Use the following links to get started using the Amazon CloudWatch API Reference:
-//
-//   Actions (http://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Operations.html):
-// An alphabetical list of all Amazon CloudWatch actions.  Data Types (http://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Types.html):
-// An alphabetical list of all Amazon CloudWatch data types.  Common Parameters
-// (http://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/CommonParameters.html):
-// Parameters that all Query actions can use.  Common Errors (http://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/CommonErrors.html):
-// Client and server errors that all actions can return.  Regions and Endpoints
-// (http://docs.aws.amazon.com/general/latest/gr/index.html?rande.html): Itemized
-// regions and endpoints for all AWS products.  WSDL Location (http://monitoring.amazonaws.com/doc/2010-08-01/CloudWatch.wsdl):
-// http://monitoring.amazonaws.com/doc/2010-08-01/CloudWatch.wsdl  In addition
-// to using the Amazon CloudWatch API, you can also use the following SDKs and
-// third-party libraries to access Amazon CloudWatch programmatically.
-//
-//  AWS SDK for Java Documentation (http://aws.amazon.com/documentation/sdkforjava/)
-// AWS SDK for .NET Documentation (http://aws.amazon.com/documentation/sdkfornet/)
-// AWS SDK for PHP Documentation (http://aws.amazon.com/documentation/sdkforphp/)
-// AWS SDK for Ruby Documentation (http://aws.amazon.com/documentation/sdkforruby/)
-//  Developers in the AWS developer community also provide their own libraries,
-// which you can find at the following AWS developer centers:
-//
-//  AWS Java Developer Center (http://aws.amazon.com/java/) AWS PHP Developer
-// Center (http://aws.amazon.com/php/) AWS Python Developer Center (http://aws.amazon.com/python/)
-// AWS Ruby Developer Center (http://aws.amazon.com/ruby/) AWS Windows and .NET
-// Developer Center (http://aws.amazon.com/net/)
-//The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
-type CloudWatch struct {
-	*client.Client
-}
-
-// Used for custom client initialization logic
-var initClient func(*client.Client)
-
-// Used for custom request initialization logic
-var initRequest func(*request.Request)
-
-// A ServiceName is the name of the service the client will make API calls to.
-const ServiceName = "monitoring"
-
-// New creates a new instance of the CloudWatch client with a session.
-// If additional configuration is needed for the client instance use the optional
-// aws.Config parameter to add your extra config.
-//
-// Example:
-//     // Create a CloudWatch client from just a session.
-//     svc := cloudwatch.New(mySession)
-//
-//     // Create a CloudWatch client with additional configuration
-//     svc := cloudwatch.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
-func New(p client.ConfigProvider, cfgs ...*aws.Config) *CloudWatch {
-	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
-}
-
-// newClient creates, initializes and returns a new service client instance.
-func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion string) *CloudWatch {
-	svc := &CloudWatch{
-		Client: client.New(
-			cfg,
-			metadata.ClientInfo{
-				ServiceName:   ServiceName,
-				SigningRegion: signingRegion,
-				Endpoint:      endpoint,
-				APIVersion:    "2010-08-01",
-			},
-			handlers,
-		),
-	}
-
-	// Handlers
-	svc.Handlers.Sign.PushBack(v4.Sign)
-	svc.Handlers.Build.PushBack(query.Build)
-	svc.Handlers.Unmarshal.PushBack(query.Unmarshal)
-	svc.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
-	svc.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
-
-	// Run custom client initialization if present
-	if initClient != nil {
-		initClient(svc.Client)
-	}
-
-	return svc
-}
-
-// newRequest creates a new request for a CloudWatch operation and runs any
-// custom request initialization.
-func (c *CloudWatch) newRequest(op *request.Operation, params, data interface{}) *request.Request {
-	req := c.NewRequest(op, params, data)
-
-	// Run custom request initialization if present
-	if initRequest != nil {
-		initRequest(req)
-	}
-
-	return req
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/api.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/api.go
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/customizations_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/customizations_test.go
@@ -1,35 +0,0 @@
-package ec2_test
-
-import (
-	"io/ioutil"
-	"net/url"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/awstesting/unit"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCopySnapshotPresignedURL(t *testing.T) {
-	svc := ec2.New(unit.Session, &aws.Config{Region: aws.String("us-west-2")})
-
-	assert.NotPanics(t, func() {
-		// Doesn't panic on nil input
-		req, _ := svc.CopySnapshotRequest(nil)
-		req.Sign()
-	})
-
-	req, _ := svc.CopySnapshotRequest(&ec2.CopySnapshotInput{
-		SourceRegion:     aws.String("us-west-1"),
-		SourceSnapshotId: aws.String("snap-id"),
-	})
-	req.Sign()
-
-	b, _ := ioutil.ReadAll(req.HTTPRequest.Body)
-	q, _ := url.ParseQuery(string(b))
-	u, _ := url.QueryUnescape(q.Get("PresignedUrl"))
-	assert.Equal(t, "us-west-2", q.Get("DestinationRegion"))
-	assert.Equal(t, "us-west-1", q.Get("SourceRegion"))
-	assert.Regexp(t, `^https://ec2\.us-west-1\.amazonaws\.com/.+&DestinationRegion=us-west-2`, u)
-}
--- a/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/examples_test.go
+++ b/Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/examples_test.go
--- a/Godeps/_workspace/src/github.com/franela/goreq/.gitignore
+++ b/Godeps/_workspace/src/github.com/franela/goreq/.gitignore
@@ -1,24 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-
-src
--- a/Godeps/_workspace/src/github.com/franela/goreq/.travis.yml
+++ b/Godeps/_workspace/src/github.com/franela/goreq/.travis.yml
@@ -1,8 +0,0 @@
-language: go
-go:
- - 1.5.3
- - tip
-notifications:
-  email:
-      - ionathan@gmail.com
-      - marcosnils@gmail.com
--- a/Godeps/_workspace/src/github.com/franela/goreq/Makefile
+++ b/Godeps/_workspace/src/github.com/franela/goreq/Makefile
@@ -1,3 +0,0 @@
-test:
-	go get -v -d -t ./...
-	go test -v
--- a/Godeps/_workspace/src/github.com/franela/goreq/README.md
+++ b/Godeps/_workspace/src/github.com/franela/goreq/README.md
@@ -1,444 +0,0 @@
-[![Build Status](https://img.shields.io/travis/franela/goreq/master.svg)](https://travis-ci.org/franela/goreq)
-[![GoDoc](https://godoc.org/github.com/franela/goreq?status.svg)](https://godoc.org/github.com/franela/goreq)
-
-GoReq
-=======
-
-Simple and sane HTTP request library for Go language.
-
-
-
-**Table of Contents**
-
- [Why GoReq?](#user-content-why-goreq)
- [How do I install it?](#user-content-how-do-i-install-it)
- [What can I do with it?](#user-content-what-can-i-do-with-it)
-  - [Making requests with different methods](#user-content-making-requests-with-different-methods)
-  - [GET](#user-content-get)
-    - [Tags](#user-content-tags)
-  - [POST](#user-content-post)
-    - [Sending payloads in the Body](#user-content-sending-payloads-in-the-body)
-  - [Specifiying request headers](#user-content-specifiying-request-headers)
-  - [Sending Cookies](#cookie-support)
-  - [Setting timeouts](#user-content-setting-timeouts)
- - [Using the Response and Error](#user-content-using-the-response-and-error)
- - [Receiving JSON](#user-content-receiving-json)
- - [Sending/Receiving Compressed Payloads](#user-content-sendingreceiving-compressed-payloads)
-    - [Using gzip compression:](#user-content-using-gzip-compression)
-    - [Using deflate compression:](#user-content-using-deflate-compression)
-    - [Using compressed responses:](#user-content-using-compressed-responses)
- - [Proxy](#proxy)
- - [Debugging requests](#debug)
-     - [Getting raw Request & Response](#getting-raw-request--response)
- - [TODO:](#user-content-todo)
-
-
-
-Why GoReq?
-==========
-
-Go has very nice native libraries that allows you to do lots of cool things. But sometimes those libraries are too low level, which means that to do a simple thing, like an HTTP Request, it takes some time. And if you want to do something as simple as adding a timeout to a request, you will end up writing several lines of code.
-
-This is why we think GoReq is useful. Because you can do all your HTTP requests in a very simple and comprehensive way, while enabling you to do more advanced stuff by giving you access to the native API.
-
-How do I install it?
-====================
-
-```bash
-go get github.com/franela/goreq
-```
-
-What can I do with it?
-======================
-
-## Making requests with different methods
-
-#### GET
-```go
-res, err := goreq.Request{ Uri: "http://www.google.com" }.Do()
-```
-
-GoReq default method is GET.
-
-You can also set value to GET method easily
-
-```go
-type Item struct {
-        Limit int
-        Skip int
-        Fields string
-}
-
-item := Item {
-        Limit: 3,
-        Skip: 5,
-        Fields: "Value",
-}
-
-res, err := goreq.Request{
-        Uri: "http://localhost:3000/",
-        QueryString: item,
-}.Do()
-```
-The sample above will send `http://localhost:3000/?limit=3&skip=5&fields=Value`
-
-Alternatively the `url` tag can be used in struct fields to customize encoding properties
-
-```go
-type Item struct {
-        TheLimit int `url:"the_limit"`
-        TheSkip string `url:"the_skip,omitempty"`
-        TheFields string `url:"-"`
-}
-
-item := Item {
-        TheLimit: 3,
-        TheSkip: "",
-        TheFields: "Value",
-}
-
-res, err := goreq.Request{
-        Uri: "http://localhost:3000/",
-        QueryString: item,
-}.Do()
-```
-The sample above will send `http://localhost:3000/?the_limit=3`
-
-
-QueryString also support url.Values
-
-```go
-item := url.Values{}
-item.Set("Limit", 3)
-item.Add("Field", "somefield")
-item.Add("Field", "someotherfield")
-
-res, err := goreq.Request{
-        Uri: "http://localhost:3000/",
-        QueryString: item,
-}.Do()
-```
-
-The sample above will send `http://localhost:3000/?limit=3&field=somefield&field=someotherfield`
-
-### Tags
-
-Struct field `url` tag is mainly used as the request parameter name.
-Tags can be comma separated multiple values, 1st value is for naming and rest has special meanings.
-
- special tag for 1st value
-    - `-`: value is ignored if set this
-
- special tag for rest 2nd value
-    - `omitempty`: zero-value is ignored if set this
-    - `squash`: the fields of embedded struct is used for parameter
-
-#### Tag Examples
-
-```go
-type Place struct {
-    Country string `url:"country"`
-    City    string `url:"city"`
-    ZipCode string `url:"zipcode,omitempty"`
-}
-
-type Person struct {
-    Place `url:",squash"`
-
-    FirstName string `url:"first_name"`
-    LastName  string `url:"last_name"`
-    Age       string `url:"age,omitempty"`
-    Password  string `url:"-"`
-}
-
-johnbull := Person{
-	Place: Place{ // squash the embedded struct value
-		Country: "UK",
-		City:    "London",
-		ZipCode: "SW1",
-	},
-	FirstName: "John",
-	LastName:  "Doe",
-	Age:       "35",
-	Password:  "my-secret", // ignored for parameter
-}
-
-goreq.Request{
-	Uri:         "http://localhost/",
-	QueryString: johnbull,
-}.Do()
-// =>  `http://localhost/?first_name=John&last_name=Doe&age=35&country=UK&city=London&zip_code=SW1`
-
-
-// age and zipcode will be ignored because of `omitempty`
-// but firstname isn't.
-samurai := Person{
-	Place: Place{ // squash the embedded struct value
-		Country: "Japan",
-		City:    "Tokyo",
-	},
-	LastName: "Yagyu",
-}
-
-goreq.Request{
-	Uri:         "http://localhost/",
-	QueryString: samurai,
-}.Do()
-// =>  `http://localhost/?first_name=&last_name=yagyu&country=Japan&city=Tokyo`
-```
-
-
-#### POST
-
-```go
-res, err := goreq.Request{ Method: "POST", Uri: "http://www.google.com" }.Do()
-```
-
-## Sending payloads in the Body
-
-You can send ```string```, ```Reader``` or ```interface{}``` in the body. The first two will be sent as text. The last one will be marshalled to JSON, if possible.
-
-```go
-type Item struct {
-    Id int
-    Name string
-}
-
-item := Item{ Id: 1111, Name: "foobar" }
-
-res, err := goreq.Request{
-    Method: "POST",
-    Uri: "http://www.google.com",
-    Body: item,
-}.Do()
-```
-
-## Specifiying request headers
-
-We think that most of the times the request headers that you use are: ```Host```, ```Content-Type```, ```Accept``` and ```User-Agent```. This is why we decided to make it very easy to set these headers.
-
-```go
-res, err := goreq.Request{
-    Uri: "http://www.google.com",
-    Host: "foobar.com",
-    Accept: "application/json",
-    ContentType: "application/json",
-    UserAgent: "goreq",
-}.Do()
-```
-
-But sometimes you need to set other headers. You can still do it.
-
-```go
-req := goreq.Request{ Uri: "http://www.google.com" }
-
-req.AddHeader("X-Custom", "somevalue")
-
-req.Do()
-```
-
-Alternatively you can use the `WithHeader` function to keep the syntax short
-
-```go
-res, err = goreq.Request{ Uri: "http://www.google.com" }.WithHeader("X-Custom", "somevalue").Do()
-```
-
-## Cookie support
-
-Cookies can be either set at the request level by sending a [CookieJar](http://golang.org/pkg/net/http/cookiejar/) in the `CookieJar` request field
-or you can use goreq's one-liner WithCookie method as shown below
-
-```go
-res, err := goreq.Request{
-    Uri: "http://www.google.com",
-}.
-WithCookie(&http.Cookie{Name: "c1", Value: "v1"}).
-Do()
-```
-
-## Setting timeouts
-
-GoReq supports 2 kind of timeouts. A general connection timeout and a request specific one. By default the connection timeout is of 1 second. There is no default for request timeout, which means it will wait forever.
-
-You can change the connection timeout doing:
-
-```go
-goreq.SetConnectTimeout(100 * time.Millisecond)
-```
-
-And specify the request timeout doing:
-
-```go
-res, err := goreq.Request{
-    Uri: "http://www.google.com",
-    Timeout: 500 * time.Millisecond,
-}.Do()
-```
-
-## Using the Response and Error
-
-GoReq will always return 2 values: a ```Response``` and an ```Error```.
-If ```Error``` is not ```nil``` it means that an error happened while doing the request and you shouldn't use the ```Response``` in any way.
-You can check what happened by getting the error message:
-
-```go
-fmt.Println(err.Error())
-```
-And to make it easy to know if it was a timeout error, you can ask the error or return it:
-
-```go
-if serr, ok := err.(*goreq.Error); ok {
-    if serr.Timeout() {
-        ...
-    }
-}
-return err
-```
-
-If you don't get an error, you can safely use the ```Response```.
-
-```go
-res.Uri // return final URL location of the response (fulfilled after redirect was made)
-res.StatusCode // return the status code of the response
-res.Body // gives you access to the body
-res.Body.ToString() // will return the body as a string
-res.Header.Get("Content-Type") // gives you access to all the response headers
-```
-Remember that you should **always** close `res.Body` if it's not `nil`
-
-## Receiving JSON
-
-GoReq will help you to receive and unmarshal JSON.
-
-```go
-type Item struct {
-    Id int
-    Name string
-}
-
-var item Item
-
-res.Body.FromJsonTo(&item)
-```
-
-## Sending/Receiving Compressed Payloads
-GoReq supports gzip, deflate and zlib compression of requests' body and transparent decompression of responses provided they have a correct `Content-Encoding` header.
-
-#####Using gzip compression:
-```go
-res, err := goreq.Request{
-    Method: "POST",
-    Uri: "http://www.google.com",
-    Body: item,
-    Compression: goreq.Gzip(),
-}.Do()
-```
-#####Using deflate/zlib compression:
-```go
-res, err := goreq.Request{
-    Method: "POST",
-    Uri: "http://www.google.com",
-    Body: item,
-    Compression: goreq.Deflate(),
-}.Do()
-```
-#####Using compressed responses:
-If servers replies a correct and matching `Content-Encoding` header (gzip requires `Content-Encoding: gzip` and deflate `Content-Encoding: deflate`) goreq transparently decompresses the response so the previous example should always work:
-```go
-type Item struct {
-    Id int
-    Name string
-}
-res, err := goreq.Request{
-    Method: "POST",
-    Uri: "http://www.google.com",
-    Body: item,
-    Compression: goreq.Gzip(),
-}.Do()
-var item Item
-res.Body.FromJsonTo(&item)
-```
-If no `Content-Encoding` header is replied by the server GoReq will return the crude response.
-
-## Proxy
-If you need to use a proxy for your requests GoReq supports the standard `http_proxy` env variable as well as manually setting the proxy for each request
-
-```go
-res, err := goreq.Request{
-    Method: "GET",
-    Proxy: "http://myproxy:myproxyport",
-    Uri: "http://www.google.com",
-}.Do()
-```
-
-### Proxy basic auth is also supported
-
-```go
-res, err := goreq.Request{
-    Method: "GET",
-    Proxy: "http://user:pass@myproxy:myproxyport",
-    Uri: "http://www.google.com",
-}.Do()
-```
-
-## Debug
-If you need to debug your http requests, it can print the http request detail.
-
-```go
-res, err := goreq.Request{
-	Method:      "GET",
-	Uri:         "http://www.google.com",
-	Compression: goreq.Gzip(),
-	ShowDebug:   true,
-}.Do()
-fmt.Println(res, err)
-```
-
-and it will print the log:
-```
-GET / HTTP/1.1
-Host: www.google.com
-Accept:
-Accept-Encoding: gzip
-Content-Encoding: gzip
-Content-Type:
-```
-
-
-### Getting raw Request & Response 
-
-To get the Request:
-
-```go
-req := goreq.Request{
-        Host: "foobar.com",
-}
-
-//req.Request will return a new instance of an http.Request so you can safely use it for something else
-request, _ := req.NewRequest()
-
-```
-
-
-To get the Response:
-
-```go
-res, err := goreq.Request{
-	Method:      "GET",
-	Uri:         "http://www.google.com",
-	Compression: goreq.Gzip(),
-	ShowDebug:   true,
-}.Do()
-
-// res.Response will contain the original http.Response structure 
-fmt.Println(res.Response, err)
-```
-
-
-
-
-TODO:
-----
-
-We do have a couple of [issues](https://github.com/franela/goreq/issues) pending we'll be addressing soon. But feel free to
-contribute and send us PRs (with tests please :smile:).
--- a/Godeps/_workspace/src/github.com/franela/goreq/goreq.go
+++ b/Godeps/_workspace/src/github.com/franela/goreq/goreq.go
@@ -1,491 +0,0 @@
-package goreq
-
-import (
-	"bufio"
-	"bytes"
-	"compress/gzip"
-	"compress/zlib"
-	"crypto/tls"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"reflect"
-	"strings"
-	"time"
-)
-
-type itimeout interface {
-	Timeout() bool
-}
-type Request struct {
-	headers           []headerTuple
-	cookies           []*http.Cookie
-	Method            string
-	Uri               string
-	Body              interface{}
-	QueryString       interface{}
-	Timeout           time.Duration
-	ContentType       string
-	Accept            string
-	Host              string
-	UserAgent         string
-	Insecure          bool
-	MaxRedirects      int
-	RedirectHeaders   bool
-	Proxy             string
-	Compression       *compression
-	BasicAuthUsername string
-	BasicAuthPassword string
-	CookieJar         http.CookieJar
-	ShowDebug         bool
-	OnBeforeRequest   func(goreq *Request, httpreq *http.Request)
-}
-
-type compression struct {
-	writer          func(buffer io.Writer) (io.WriteCloser, error)
-	reader          func(buffer io.Reader) (io.ReadCloser, error)
-	ContentEncoding string
-}
-
-type Response struct {
-	*http.Response
-	Uri  string
-	Body *Body
-	req  *http.Request
-}
-
-func (r Response) CancelRequest() {
-	cancelRequest(DefaultTransport, r.req)
-
-}
-
-func cancelRequest(transport interface{}, r *http.Request) {
-	if tp, ok := transport.(transportRequestCanceler); ok {
-		tp.CancelRequest(r)
-	}
-}
-
-type headerTuple struct {
-	name  string
-	value string
-}
-
-type Body struct {
-	reader           io.ReadCloser
-	compressedReader io.ReadCloser
-}
-
-type Error struct {
-	timeout bool
-	Err     error
-}
-
-type transportRequestCanceler interface {
-	CancelRequest(*http.Request)
-}
-
-func (e *Error) Timeout() bool {
-	return e.timeout
-}
-
-func (e *Error) Error() string {
-	return e.Err.Error()
-}
-
-func (b *Body) Read(p []byte) (int, error) {
-	if b.compressedReader != nil {
-		return b.compressedReader.Read(p)
-	}
-	return b.reader.Read(p)
-}
-
-func (b *Body) Close() error {
-	err := b.reader.Close()
-	if b.compressedReader != nil {
-		return b.compressedReader.Close()
-	}
-	return err
-}
-
-func (b *Body) FromJsonTo(o interface{}) error {
-	return json.NewDecoder(b).Decode(o)
-}
-
-func (b *Body) ToString() (string, error) {
-	body, err := ioutil.ReadAll(b)
-	if err != nil {
-		return "", err
-	}
-	return string(body), nil
-}
-
-func Gzip() *compression {
-	reader := func(buffer io.Reader) (io.ReadCloser, error) {
-		return gzip.NewReader(buffer)
-	}
-	writer := func(buffer io.Writer) (io.WriteCloser, error) {
-		return gzip.NewWriter(buffer), nil
-	}
-	return &compression{writer: writer, reader: reader, ContentEncoding: "gzip"}
-}
-
-func Deflate() *compression {
-	reader := func(buffer io.Reader) (io.ReadCloser, error) {
-		return zlib.NewReader(buffer)
-	}
-	writer := func(buffer io.Writer) (io.WriteCloser, error) {
-		return zlib.NewWriter(buffer), nil
-	}
-	return &compression{writer: writer, reader: reader, ContentEncoding: "deflate"}
-}
-
-func Zlib() *compression {
-	return Deflate()
-}
-
-func paramParse(query interface{}) (string, error) {
-	switch query.(type) {
-	case url.Values:
-		return query.(url.Values).Encode(), nil
-	case *url.Values:
-		return query.(*url.Values).Encode(), nil
-	default:
-		var v = &url.Values{}
-		err := paramParseStruct(v, query)
-		return v.Encode(), err
-	}
-}
-
-func paramParseStruct(v *url.Values, query interface{}) error {
-	var (
-		s = reflect.ValueOf(query)
-		t = reflect.TypeOf(query)
-	)
-	for t.Kind() == reflect.Ptr || t.Kind() == reflect.Interface {
-		s = s.Elem()
-		t = s.Type()
-	}
-
-	if t.Kind() != reflect.Struct {
-		return errors.New("Can not parse QueryString.")
-	}
-
-	for i := 0; i < t.NumField(); i++ {
-		var name string
-
-		field := s.Field(i)
-		typeField := t.Field(i)
-
-		if !field.CanInterface() {
-			continue
-		}
-
-		urlTag := typeField.Tag.Get("url")
-		if urlTag == "-" {
-			continue
-		}
-
-		name, opts := parseTag(urlTag)
-
-		var omitEmpty, squash bool
-		omitEmpty = opts.Contains("omitempty")
-		squash = opts.Contains("squash")
-
-		if squash {
-			err := paramParseStruct(v, field.Interface())
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		if urlTag == "" {
-			name = strings.ToLower(typeField.Name)
-		}
-
-		if val := fmt.Sprintf("%v", field.Interface()); !(omitEmpty && len(val) == 0) {
-			v.Add(name, val)
-		}
-	}
-	return nil
-}
-
-func prepareRequestBody(b interface{}) (io.Reader, error) {
-	switch b.(type) {
-	case string:
-		// treat is as text
-		return strings.NewReader(b.(string)), nil
-	case io.Reader:
-		// treat is as text
-		return b.(io.Reader), nil
-	case []byte:
-		//treat as byte array
-		return bytes.NewReader(b.([]byte)), nil
-	case nil:
-		return nil, nil
-	default:
-		// try to jsonify it
-		j, err := json.Marshal(b)
-		if err == nil {
-			return bytes.NewReader(j), nil
-		}
-		return nil, err
-	}
-}
-
-var DefaultDialer = &net.Dialer{Timeout: 1000 * time.Millisecond}
-var DefaultTransport http.RoundTripper = &http.Transport{Dial: DefaultDialer.Dial, Proxy: http.ProxyFromEnvironment}
-var DefaultClient = &http.Client{Transport: DefaultTransport}
-
-var proxyTransport http.RoundTripper
-var proxyClient *http.Client
-
-func SetConnectTimeout(duration time.Duration) {
-	DefaultDialer.Timeout = duration
-}
-
-func (r *Request) AddHeader(name string, value string) {
-	if r.headers == nil {
-		r.headers = []headerTuple{}
-	}
-	r.headers = append(r.headers, headerTuple{name: name, value: value})
-}
-
-func (r Request) WithHeader(name string, value string) Request {
-	r.AddHeader(name, value)
-	return r
-}
-
-func (r *Request) AddCookie(c *http.Cookie) {
-	r.cookies = append(r.cookies, c)
-}
-
-func (r Request) WithCookie(c *http.Cookie) Request {
-	r.AddCookie(c)
-	return r
-
-}
-
-func (r Request) Do() (*Response, error) {
-	var client = DefaultClient
-	var transport = DefaultTransport
-	var resUri string
-	var redirectFailed bool
-
-	r.Method = valueOrDefault(r.Method, "GET")
-
-	// use a client with a cookie jar if necessary. We create a new client not
-	// to modify the default one.
-	if r.CookieJar != nil {
-		client = &http.Client{
-			Transport: transport,
-			Jar:       r.CookieJar,
-		}
-	}
-
-	if r.Proxy != "" {
-		proxyUrl, err := url.Parse(r.Proxy)
-		if err != nil {
-			// proxy address is in a wrong format
-			return nil, &Error{Err: err}
-		}
-
-		//If jar is specified new client needs to be built
-		if proxyTransport == nil || client.Jar != nil {
-			proxyTransport = &http.Transport{Dial: DefaultDialer.Dial, Proxy: http.ProxyURL(proxyUrl)}
-			proxyClient = &http.Client{Transport: proxyTransport, Jar: client.Jar}
-		} else if proxyTransport, ok := proxyTransport.(*http.Transport); ok {
-			proxyTransport.Proxy = http.ProxyURL(proxyUrl)
-		}
-		transport = proxyTransport
-		client = proxyClient
-	}
-
-	client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
-
-		if len(via) > r.MaxRedirects {
-			redirectFailed = true
-			return errors.New("Error redirecting. MaxRedirects reached")
-		}
-
-		resUri = req.URL.String()
-
-		//By default Golang will not redirect request headers
-		// https://code.google.com/p/go/issues/detail?id=4800&q=request%20header
-		if r.RedirectHeaders {
-			for key, val := range via[0].Header {
-				req.Header[key] = val
-			}
-		}
-		return nil
-	}
-
-	if transport, ok := transport.(*http.Transport); ok {
-		if r.Insecure {
-			if transport.TLSClientConfig != nil {
-				transport.TLSClientConfig.InsecureSkipVerify = true
-			} else {
-				transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
-			}
-		} else if transport.TLSClientConfig != nil {
-			// the default TLS client (when transport.TLSClientConfig==nil) is
-			// already set to verify, so do nothing in that case
-			transport.TLSClientConfig.InsecureSkipVerify = false
-		}
-	}
-
-	req, err := r.NewRequest()
-
-	if err != nil {
-		// we couldn't parse the URL.
-		return nil, &Error{Err: err}
-	}
-
-	timeout := false
-	if r.Timeout > 0 {
-		client.Timeout = r.Timeout
-	}
-
-	if r.ShowDebug {
-		dump, err := httputil.DumpRequest(req, true)
-		if err != nil {
-			log.Println(err)
-		}
-		log.Println(string(dump))
-	}
-
-	if r.OnBeforeRequest != nil {
-		r.OnBeforeRequest(&r, req)
-	}
-	res, err := client.Do(req)
-
-	if err != nil {
-		if !timeout {
-			if t, ok := err.(itimeout); ok {
-				timeout = t.Timeout()
-			}
-			if ue, ok := err.(*url.Error); ok {
-				if t, ok := ue.Err.(itimeout); ok {
-					timeout = t.Timeout()
-				}
-			}
-		}
-
-		var response *Response
-		//If redirect fails we still want to return response data
-		if redirectFailed {
-			if res != nil {
-				response = &Response{res, resUri, &Body{reader: res.Body}, req}
-			} else {
-				response = &Response{res, resUri, nil, req}
-			}
-		}
-
-		//If redirect fails and we haven't set a redirect count we shouldn't return an error
-		if redirectFailed && r.MaxRedirects == 0 {
-			return response, nil
-		}
-
-		return response, &Error{timeout: timeout, Err: err}
-	}
-
-	if r.Compression != nil && strings.Contains(res.Header.Get("Content-Encoding"), r.Compression.ContentEncoding) {
-		compressedReader, err := r.Compression.reader(res.Body)
-		if err != nil {
-			return nil, &Error{Err: err}
-		}
-		return &Response{res, resUri, &Body{reader: res.Body, compressedReader: compressedReader}, req}, nil
-	}
-
-	return &Response{res, resUri, &Body{reader: res.Body}, req}, nil
-}
-
-func (r Request) addHeaders(headersMap http.Header) {
-	if len(r.UserAgent) > 0 {
-		headersMap.Add("User-Agent", r.UserAgent)
-	}
-	if r.Accept != "" {
-		headersMap.Add("Accept", r.Accept)
-	}
-	if r.ContentType != "" {
-		headersMap.Add("Content-Type", r.ContentType)
-	}
-}
-
-func (r Request) NewRequest() (*http.Request, error) {
-
-	b, e := prepareRequestBody(r.Body)
-	if e != nil {
-		// there was a problem marshaling the body
-		return nil, &Error{Err: e}
-	}
-
-	if r.QueryString != nil {
-		param, e := paramParse(r.QueryString)
-		if e != nil {
-			return nil, &Error{Err: e}
-		}
-		r.Uri = r.Uri + "?" + param
-	}
-
-	var bodyReader io.Reader
-	if b != nil && r.Compression != nil {
-		buffer := bytes.NewBuffer([]byte{})
-		readBuffer := bufio.NewReader(b)
-		writer, err := r.Compression.writer(buffer)
-		if err != nil {
-			return nil, &Error{Err: err}
-		}
-		_, e = readBuffer.WriteTo(writer)
-		writer.Close()
-		if e != nil {
-			return nil, &Error{Err: e}
-		}
-		bodyReader = buffer
-	} else {
-		bodyReader = b
-	}
-
-	req, err := http.NewRequest(r.Method, r.Uri, bodyReader)
-	if err != nil {
-		return nil, err
-	}
-	// add headers to the request
-	req.Host = r.Host
-
-	r.addHeaders(req.Header)
-	if r.Compression != nil {
-		req.Header.Add("Content-Encoding", r.Compression.ContentEncoding)
-		req.Header.Add("Accept-Encoding", r.Compression.ContentEncoding)
-	}
-	if r.headers != nil {
-		for _, header := range r.headers {
-			req.Header.Add(header.name, header.value)
-		}
-	}
-
-	//use basic auth if required
-	if r.BasicAuthUsername != "" {
-		req.SetBasicAuth(r.BasicAuthUsername, r.BasicAuthPassword)
-	}
-
-	for _, c := range r.cookies {
-		req.AddCookie(c)
-	}
-	return req, nil
-}
-
-// Return value if nonempty, def otherwise.
-func valueOrDefault(value, def string) string {
-	if value != "" {
-		return value
-	}
-	return def
-}
--- a/Godeps/_workspace/src/github.com/franela/goreq/tags.go
+++ b/Godeps/_workspace/src/github.com/franela/goreq/tags.go
@@ -1,64 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package goreq
-
-import (
-	"strings"
-	"unicode"
-)
-
-// tagOptions is the string following a comma in a struct field's "json"
-// tag, or the empty string. It does not include the leading comma.
-type tagOptions string
-
-// parseTag splits a struct field's json tag into its name and
-// comma-separated options.
-func parseTag(tag string) (string, tagOptions) {
-	if idx := strings.Index(tag, ","); idx != -1 {
-		return tag[:idx], tagOptions(tag[idx+1:])
-	}
-	return tag, tagOptions("")
-}
-
-// Contains reports whether a comma-separated list of options
-// contains a particular substr flag. substr must be surrounded by a
-// string boundary or commas.
-func (o tagOptions) Contains(optionName string) bool {
-	if len(o) == 0 {
-		return false
-	}
-	s := string(o)
-	for s != "" {
-		var next string
-		i := strings.Index(s, ",")
-		if i >= 0 {
-			s, next = s[:i], s[i+1:]
-		}
-		if s == optionName {
-			return true
-		}
-		s = next
-	}
-	return false
-}
-
-func isValidTag(s string) bool {
-	if s == "" {
-		return false
-	}
-	for _, c := range s {
-		switch {
-		case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c):
-			// Backslash and quote chars are reserved, but
-			// otherwise any punctuation chars are allowed
-			// in a tag name.
-		default:
-			if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
-				return false
-			}
-		}
-	}
-	return true
-}
--- a/Godeps/_workspace/src/github.com/go-ini/ini/ini.go
+++ b/Godeps/_workspace/src/github.com/go-ini/ini/ini.go
--- a/Godeps/_workspace/src/github.com/go-ini/ini/ini_test.go
+++ b/Godeps/_workspace/src/github.com/go-ini/ini/ini_test.go
@@ -1,512 +0,0 @@
-// Copyright 2014 Unknwon
-//
-// Licensed 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 ini
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-	"time"
-
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-func Test_Version(t *testing.T) {
-	Convey("Get version", t, func() {
-		So(Version(), ShouldEqual, _VERSION)
-	})
-}
-
-const _CONF_DATA = `
-; Package name
-NAME = ini
-; Package version
-VERSION = v1
-; Package import path
-IMPORT_PATH = gopkg.in/%(NAME)s.%(VERSION)s
-
-# Information about package author
-# Bio can be written in multiple lines.
-[author]
-NAME = Unknwon  # Succeeding comment
-E-MAIL = fake@localhost
-GITHUB = https://github.com/%(NAME)s
-BIO = """Gopher.
-Coding addict.
-Good man.
-"""  # Succeeding comment
-
-[package]
-CLONE_URL = https://%(IMPORT_PATH)s
-
-[package.sub]
-UNUSED_KEY = should be deleted
-
-[features]
-: Support read/write comments of keys and sections
-: Support auto-increment of key names
-: Support load multiple files to overwrite key values
-
-[types]
-STRING = str
-BOOL = true
-BOOL_FALSE = false
-FLOAT64 = 1.25
-INT = 10
-TIME = 2015-01-01T20:17:05Z
-DURATION = 2h45m
-UINT = 3
-
-[array]
-STRINGS = en, zh, de
-FLOAT64S = 1.1, 2.2, 3.3
-INTS = 1, 2, 3
-UINTS = 1, 2, 3
-TIMES = 2015-01-01T20:17:05Z,2015-01-01T20:17:05Z,2015-01-01T20:17:05Z
-
-[note]
-empty_lines = next line is empty\
-
-[advance]
-value with quotes = "some value"
-value quote2 again = 'some value'
-true = """"2+3=5""""
-"1+1=2" = true
-"""6+1=7""" = true
-"""` + "`" + `5+5` + "`" + `""" = 10
-""""6+6"""" = 12
-` + "`" + `7-2=4` + "`" + ` = false
-ADDRESS = ` + "`" + `404 road,
-NotFound, State, 50000` + "`" + `
-
-two_lines = how about \
-	continuation lines?
-lots_of_lines = 1 \
-	2 \
-	3 \
-	4 \
-`
-
-func Test_Load(t *testing.T) {
-	Convey("Load from data sources", t, func() {
-
-		Convey("Load with empty data", func() {
-			So(Empty(), ShouldNotBeNil)
-		})
-
-		Convey("Load with multiple data sources", func() {
-			cfg, err := Load([]byte(_CONF_DATA), "testdata/conf.ini")
-			So(err, ShouldBeNil)
-			So(cfg, ShouldNotBeNil)
-		})
-	})
-
-	Convey("Bad load process", t, func() {
-
-		Convey("Load from invalid data sources", func() {
-			_, err := Load(_CONF_DATA)
-			So(err, ShouldNotBeNil)
-
-			_, err = Load("testdata/404.ini")
-			So(err, ShouldNotBeNil)
-
-			_, err = Load(1)
-			So(err, ShouldNotBeNil)
-
-			_, err = Load([]byte(""), 1)
-			So(err, ShouldNotBeNil)
-		})
-
-		Convey("Load with empty section name", func() {
-			_, err := Load([]byte("[]"))
-			So(err, ShouldNotBeNil)
-		})
-
-		Convey("Load with bad keys", func() {
-			_, err := Load([]byte(`"""name`))
-			So(err, ShouldNotBeNil)
-
-			_, err = Load([]byte(`"""name"""`))
-			So(err, ShouldNotBeNil)
-
-			_, err = Load([]byte(`""=1`))
-			So(err, ShouldNotBeNil)
-
-			_, err = Load([]byte(`=`))
-			So(err, ShouldNotBeNil)
-
-			_, err = Load([]byte(`name`))
-			So(err, ShouldNotBeNil)
-		})
-
-		Convey("Load with bad values", func() {
-			_, err := Load([]byte(`name="""Unknwon`))
-			So(err, ShouldNotBeNil)
-
-			_, err = Load([]byte(`key = "value`))
-			So(err, ShouldNotBeNil)
-		})
-	})
-}
-
-func Test_Values(t *testing.T) {
-	Convey("Test getting and setting values", t, func() {
-		cfg, err := Load([]byte(_CONF_DATA), "testdata/conf.ini")
-		So(err, ShouldBeNil)
-		So(cfg, ShouldNotBeNil)
-
-		Convey("Get values in default section", func() {
-			sec := cfg.Section("")
-			So(sec, ShouldNotBeNil)
-			So(sec.Key("NAME").Value(), ShouldEqual, "ini")
-			So(sec.Key("NAME").String(), ShouldEqual, "ini")
-			So(sec.Key("NAME").Validate(func(in string) string {
-				return in
-			}), ShouldEqual, "ini")
-			So(sec.Key("NAME").Comment, ShouldEqual, "; Package name")
-			So(sec.Key("IMPORT_PATH").String(), ShouldEqual, "gopkg.in/ini.v1")
-		})
-
-		Convey("Get values in non-default section", func() {
-			sec := cfg.Section("author")
-			So(sec, ShouldNotBeNil)
-			So(sec.Key("NAME").String(), ShouldEqual, "Unknwon")
-			So(sec.Key("GITHUB").String(), ShouldEqual, "https://github.com/Unknwon")
-
-			sec = cfg.Section("package")
-			So(sec, ShouldNotBeNil)
-			So(sec.Key("CLONE_URL").String(), ShouldEqual, "https://gopkg.in/ini.v1")
-		})
-
-		Convey("Get auto-increment key names", func() {
-			keys := cfg.Section("features").Keys()
-			for i, k := range keys {
-				So(k.Name(), ShouldEqual, fmt.Sprintf("#%d", i+1))
-			}
-		})
-
-		Convey("Get overwrite value", func() {
-			So(cfg.Section("author").Key("E-MAIL").String(), ShouldEqual, "u@gogs.io")
-		})
-
-		Convey("Get sections", func() {
-			sections := cfg.Sections()
-			for i, name := range []string{DEFAULT_SECTION, "author", "package", "package.sub", "features", "types", "array", "note", "advance"} {
-				So(sections[i].Name(), ShouldEqual, name)
-			}
-		})
-
-		Convey("Get parent section value", func() {
-			So(cfg.Section("package.sub").Key("CLONE_URL").String(), ShouldEqual, "https://gopkg.in/ini.v1")
-		})
-
-		Convey("Get multiple line value", func() {
-			So(cfg.Section("author").Key("BIO").String(), ShouldEqual, "Gopher.\nCoding addict.\nGood man.\n")
-		})
-
-		Convey("Get values with type", func() {
-			sec := cfg.Section("types")
-			v1, err := sec.Key("BOOL").Bool()
-			So(err, ShouldBeNil)
-			So(v1, ShouldBeTrue)
-
-			v1, err = sec.Key("BOOL_FALSE").Bool()
-			So(err, ShouldBeNil)
-			So(v1, ShouldBeFalse)
-
-			v2, err := sec.Key("FLOAT64").Float64()
-			So(err, ShouldBeNil)
-			So(v2, ShouldEqual, 1.25)
-
-			v3, err := sec.Key("INT").Int()
-			So(err, ShouldBeNil)
-			So(v3, ShouldEqual, 10)
-
-			v4, err := sec.Key("INT").Int64()
-			So(err, ShouldBeNil)
-			So(v4, ShouldEqual, 10)
-
-			v5, err := sec.Key("UINT").Uint()
-			So(err, ShouldBeNil)
-			So(v5, ShouldEqual, 3)
-
-			v6, err := sec.Key("UINT").Uint64()
-			So(err, ShouldBeNil)
-			So(v6, ShouldEqual, 3)
-
-			t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z")
-			So(err, ShouldBeNil)
-			v7, err := sec.Key("TIME").Time()
-			So(err, ShouldBeNil)
-			So(v7.String(), ShouldEqual, t.String())
-
-			Convey("Must get values with type", func() {
-				So(sec.Key("STRING").MustString("404"), ShouldEqual, "str")
-				So(sec.Key("BOOL").MustBool(), ShouldBeTrue)
-				So(sec.Key("FLOAT64").MustFloat64(), ShouldEqual, 1.25)
-				So(sec.Key("INT").MustInt(), ShouldEqual, 10)
-				So(sec.Key("INT").MustInt64(), ShouldEqual, 10)
-				So(sec.Key("UINT").MustUint(), ShouldEqual, 3)
-				So(sec.Key("UINT").MustUint64(), ShouldEqual, 3)
-				So(sec.Key("TIME").MustTime().String(), ShouldEqual, t.String())
-
-				dur, err := time.ParseDuration("2h45m")
-				So(err, ShouldBeNil)
-				So(sec.Key("DURATION").MustDuration().Seconds(), ShouldEqual, dur.Seconds())
-
-				Convey("Must get values with default value", func() {
-					So(sec.Key("STRING_404").MustString("404"), ShouldEqual, "404")
-					So(sec.Key("BOOL_404").MustBool(true), ShouldBeTrue)
-					So(sec.Key("FLOAT64_404").MustFloat64(2.5), ShouldEqual, 2.5)
-					So(sec.Key("INT_404").MustInt(15), ShouldEqual, 15)
-					So(sec.Key("INT_404").MustInt64(15), ShouldEqual, 15)
-					So(sec.Key("UINT_404").MustUint(6), ShouldEqual, 6)
-					So(sec.Key("UINT_404").MustUint64(6), ShouldEqual, 6)
-
-					t, err := time.Parse(time.RFC3339, "2014-01-01T20:17:05Z")
-					So(err, ShouldBeNil)
-					So(sec.Key("TIME_404").MustTime(t).String(), ShouldEqual, t.String())
-
-					So(sec.Key("DURATION_404").MustDuration(dur).Seconds(), ShouldEqual, dur.Seconds())
-				})
-			})
-		})
-
-		Convey("Get value with candidates", func() {
-			sec := cfg.Section("types")
-			So(sec.Key("STRING").In("", []string{"str", "arr", "types"}), ShouldEqual, "str")
-			So(sec.Key("FLOAT64").InFloat64(0, []float64{1.25, 2.5, 3.75}), ShouldEqual, 1.25)
-			So(sec.Key("INT").InInt(0, []int{10, 20, 30}), ShouldEqual, 10)
-			So(sec.Key("INT").InInt64(0, []int64{10, 20, 30}), ShouldEqual, 10)
-			So(sec.Key("UINT").InUint(0, []uint{3, 6, 9}), ShouldEqual, 3)
-			So(sec.Key("UINT").InUint64(0, []uint64{3, 6, 9}), ShouldEqual, 3)
-
-			zt, err := time.Parse(time.RFC3339, "0001-01-01T01:00:00Z")
-			So(err, ShouldBeNil)
-			t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z")
-			So(err, ShouldBeNil)
-			So(sec.Key("TIME").InTime(zt, []time.Time{t, time.Now(), time.Now().Add(1 * time.Second)}).String(), ShouldEqual, t.String())
-
-			Convey("Get value with candidates and default value", func() {
-				So(sec.Key("STRING_404").In("str", []string{"str", "arr", "types"}), ShouldEqual, "str")
-				So(sec.Key("FLOAT64_404").InFloat64(1.25, []float64{1.25, 2.5, 3.75}), ShouldEqual, 1.25)
-				So(sec.Key("INT_404").InInt(10, []int{10, 20, 30}), ShouldEqual, 10)
-				So(sec.Key("INT64_404").InInt64(10, []int64{10, 20, 30}), ShouldEqual, 10)
-				So(sec.Key("UINT_404").InUint(3, []uint{3, 6, 9}), ShouldEqual, 3)
-				So(sec.Key("UINT_404").InUint64(3, []uint64{3, 6, 9}), ShouldEqual, 3)
-				So(sec.Key("TIME_404").InTime(t, []time.Time{time.Now(), time.Now(), time.Now().Add(1 * time.Second)}).String(), ShouldEqual, t.String())
-			})
-		})
-
-		Convey("Get values in range", func() {
-			sec := cfg.Section("types")
-			So(sec.Key("FLOAT64").RangeFloat64(0, 1, 2), ShouldEqual, 1.25)
-			So(sec.Key("INT").RangeInt(0, 10, 20), ShouldEqual, 10)
-			So(sec.Key("INT").RangeInt64(0, 10, 20), ShouldEqual, 10)
-
-			minT, err := time.Parse(time.RFC3339, "0001-01-01T01:00:00Z")
-			So(err, ShouldBeNil)
-			midT, err := time.Parse(time.RFC3339, "2013-01-01T01:00:00Z")
-			So(err, ShouldBeNil)
-			maxT, err := time.Parse(time.RFC3339, "9999-01-01T01:00:00Z")
-			So(err, ShouldBeNil)
-			t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z")
-			So(err, ShouldBeNil)
-			So(sec.Key("TIME").RangeTime(t, minT, maxT).String(), ShouldEqual, t.String())
-
-			Convey("Get value in range with default value", func() {
-				So(sec.Key("FLOAT64").RangeFloat64(5, 0, 1), ShouldEqual, 5)
-				So(sec.Key("INT").RangeInt(7, 0, 5), ShouldEqual, 7)
-				So(sec.Key("INT").RangeInt64(7, 0, 5), ShouldEqual, 7)
-				So(sec.Key("TIME").RangeTime(t, minT, midT).String(), ShouldEqual, t.String())
-			})
-		})
-
-		Convey("Get values into slice", func() {
-			sec := cfg.Section("array")
-			So(strings.Join(sec.Key("STRINGS").Strings(","), ","), ShouldEqual, "en,zh,de")
-			So(len(sec.Key("STRINGS_404").Strings(",")), ShouldEqual, 0)
-
-			vals1 := sec.Key("FLOAT64S").Float64s(",")
-			for i, v := range []float64{1.1, 2.2, 3.3} {
-				So(vals1[i], ShouldEqual, v)
-			}
-
-			vals2 := sec.Key("INTS").Ints(",")
-			for i, v := range []int{1, 2, 3} {
-				So(vals2[i], ShouldEqual, v)
-			}
-
-			vals3 := sec.Key("INTS").Int64s(",")
-			for i, v := range []int64{1, 2, 3} {
-				So(vals3[i], ShouldEqual, v)
-			}
-
-			vals4 := sec.Key("UINTS").Uints(",")
-			for i, v := range []uint{1, 2, 3} {
-				So(vals4[i], ShouldEqual, v)
-			}
-
-			vals5 := sec.Key("UINTS").Uint64s(",")
-			for i, v := range []uint64{1, 2, 3} {
-				So(vals5[i], ShouldEqual, v)
-			}
-
-			t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z")
-			So(err, ShouldBeNil)
-			vals6 := sec.Key("TIMES").Times(",")
-			for i, v := range []time.Time{t, t, t} {
-				So(vals6[i].String(), ShouldEqual, v.String())
-			}
-		})
-
-		Convey("Get key hash", func() {
-			cfg.Section("").KeysHash()
-		})
-
-		Convey("Set key value", func() {
-			k := cfg.Section("author").Key("NAME")
-			k.SetValue("无闻")
-			So(k.String(), ShouldEqual, "无闻")
-		})
-
-		Convey("Get key strings", func() {
-			So(strings.Join(cfg.Section("types").KeyStrings(), ","), ShouldEqual, "STRING,BOOL,BOOL_FALSE,FLOAT64,INT,TIME,DURATION,UINT")
-		})
-
-		Convey("Delete a key", func() {
-			cfg.Section("package.sub").DeleteKey("UNUSED_KEY")
-			_, err := cfg.Section("package.sub").GetKey("UNUSED_KEY")
-			So(err, ShouldNotBeNil)
-		})
-
-		Convey("Get section strings", func() {
-			So(strings.Join(cfg.SectionStrings(), ","), ShouldEqual, "DEFAULT,author,package,package.sub,features,types,array,note,advance")
-		})
-
-		Convey("Delete a section", func() {
-			cfg.DeleteSection("")
-			So(cfg.SectionStrings()[0], ShouldNotEqual, DEFAULT_SECTION)
-		})
-
-		Convey("Create new sections", func() {
-			cfg.NewSections("test", "test2")
-			_, err := cfg.GetSection("test")
-			So(err, ShouldBeNil)
-			_, err = cfg.GetSection("test2")
-			So(err, ShouldBeNil)
-		})
-	})
-
-	Convey("Test getting and setting bad values", t, func() {
-		cfg, err := Load([]byte(_CONF_DATA), "testdata/conf.ini")
-		So(err, ShouldBeNil)
-		So(cfg, ShouldNotBeNil)
-
-		Convey("Create new key with empty name", func() {
-			k, err := cfg.Section("").NewKey("", "")
-			So(err, ShouldNotBeNil)
-			So(k, ShouldBeNil)
-		})
-
-		Convey("Create new section with empty name", func() {
-			s, err := cfg.NewSection("")
-			So(err, ShouldNotBeNil)
-			So(s, ShouldBeNil)
-		})
-
-		Convey("Create new sections with empty name", func() {
-			So(cfg.NewSections(""), ShouldNotBeNil)
-		})
-
-		Convey("Get section that not exists", func() {
-			s, err := cfg.GetSection("404")
-			So(err, ShouldNotBeNil)
-			So(s, ShouldBeNil)
-
-			s = cfg.Section("404")
-			So(s, ShouldNotBeNil)
-		})
-	})
-}
-
-func Test_File_Append(t *testing.T) {
-	Convey("Append data sources", t, func() {
-		cfg, err := Load([]byte(""))
-		So(err, ShouldBeNil)
-		So(cfg, ShouldNotBeNil)
-
-		So(cfg.Append([]byte(""), []byte("")), ShouldBeNil)
-
-		Convey("Append bad data sources", func() {
-			So(cfg.Append(1), ShouldNotBeNil)
-			So(cfg.Append([]byte(""), 1), ShouldNotBeNil)
-		})
-	})
-}
-
-func Test_File_SaveTo(t *testing.T) {
-	Convey("Save file", t, func() {
-		cfg, err := Load([]byte(_CONF_DATA), "testdata/conf.ini")
-		So(err, ShouldBeNil)
-		So(cfg, ShouldNotBeNil)
-
-		cfg.Section("").Key("NAME").Comment = "Package name"
-		cfg.Section("author").Comment = `Information about package author
-# Bio can be written in multiple lines.`
-		cfg.Section("advanced").Key("val w/ pound").SetValue("my#password")
-		So(cfg.SaveTo("testdata/conf_out.ini"), ShouldBeNil)
-
-		cfg.Section("author").Key("NAME").Comment = "This is author name"
-		So(cfg.SaveToIndent("testdata/conf_out.ini", "\t"), ShouldBeNil)
-	})
-}
-
-func Benchmark_Key_Value(b *testing.B) {
-	c, _ := Load([]byte(_CONF_DATA))
-	for i := 0; i < b.N; i++ {
-		c.Section("").Key("NAME").Value()
-	}
-}
-
-func Benchmark_Key_String(b *testing.B) {
-	c, _ := Load([]byte(_CONF_DATA))
-	for i := 0; i < b.N; i++ {
-		c.Section("").Key("NAME").String()
-	}
-}
-
-func Benchmark_Key_Value_NonBlock(b *testing.B) {
-	c, _ := Load([]byte(_CONF_DATA))
-	c.BlockMode = false
-	for i := 0; i < b.N; i++ {
-		c.Section("").Key("NAME").Value()
-	}
-}
-
-func Benchmark_Key_String_NonBlock(b *testing.B) {
-	c, _ := Load([]byte(_CONF_DATA))
-	c.BlockMode = false
-	for i := 0; i < b.N; i++ {
-		c.Section("").Key("NAME").String()
-	}
-}
-
-func Benchmark_Key_SetValue(b *testing.B) {
-	c, _ := Load([]byte(_CONF_DATA))
-	for i := 0; i < b.N; i++ {
-		c.Section("").Key("NAME").SetValue("10")
-	}
-}
--- a/Godeps/_workspace/src/github.com/go-ini/ini/struct_test.go
+++ b/Godeps/_workspace/src/github.com/go-ini/ini/struct_test.go
@@ -1,239 +0,0 @@
-// Copyright 2014 Unknwon
-//
-// Licensed 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 ini
-
-import (
-	"strings"
-	"testing"
-	"time"
-
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-type testNested struct {
-	Cities []string `delim:"|"`
-	Visits []time.Time
-	Note   string
-	Unused int `ini:"-"`
-}
-
-type testEmbeded struct {
-	GPA float64
-}
-
-type testStruct struct {
-	Name         string `ini:"NAME"`
-	Age          int
-	Male         bool
-	Money        float64
-	Born         time.Time
-	Time         time.Duration `ini:"Duration"`
-	Others       testNested
-	*testEmbeded `ini:"grade"`
-	Unused       int `ini:"-"`
-	Unsigned     uint
-}
-
-const _CONF_DATA_STRUCT = `
-NAME = Unknwon
-Age = 21
-Male = true
-Money = 1.25
-Born = 1993-10-07T20:17:05Z
-Duration = 2h45m
-Unsigned = 3
-
-[Others]
-Cities = HangZhou|Boston
-Visits = 1993-10-07T20:17:05Z, 1993-10-07T20:17:05Z
-Note = Hello world!
-
-[grade]
-GPA = 2.8
-
-[foo.bar]
-Here = there
-When = then
-`
-
-type unsupport struct {
-	Byte byte
-}
-
-type unsupport2 struct {
-	Others struct {
-		Cities byte
-	}
-}
-
-type unsupport3 struct {
-	Cities byte
-}
-
-type unsupport4 struct {
-	*unsupport3 `ini:"Others"`
-}
-
-type defaultValue struct {
-	Name   string
-	Age    int
-	Male   bool
-	Money  float64
-	Born   time.Time
-	Cities []string
-}
-
-type fooBar struct {
-	Here, When string
-}
-
-const _INVALID_DATA_CONF_STRUCT = `
-Name = 
-Age = age
-Male = 123
-Money = money
-Born = nil
-Cities = 
-`
-
-func Test_Struct(t *testing.T) {
-	Convey("Map to struct", t, func() {
-		Convey("Map file to struct", func() {
-			ts := new(testStruct)
-			So(MapTo(ts, []byte(_CONF_DATA_STRUCT)), ShouldBeNil)
-
-			So(ts.Name, ShouldEqual, "Unknwon")
-			So(ts.Age, ShouldEqual, 21)
-			So(ts.Male, ShouldBeTrue)
-			So(ts.Money, ShouldEqual, 1.25)
-			So(ts.Unsigned, ShouldEqual, 3)
-
-			t, err := time.Parse(time.RFC3339, "1993-10-07T20:17:05Z")
-			So(err, ShouldBeNil)
-			So(ts.Born.String(), ShouldEqual, t.String())
-
-			dur, err := time.ParseDuration("2h45m")
-			So(err, ShouldBeNil)
-			So(ts.Time.Seconds(), ShouldEqual, dur.Seconds())
-
-			So(strings.Join(ts.Others.Cities, ","), ShouldEqual, "HangZhou,Boston")
-			So(ts.Others.Visits[0].String(), ShouldEqual, t.String())
-			So(ts.Others.Note, ShouldEqual, "Hello world!")
-			So(ts.testEmbeded.GPA, ShouldEqual, 2.8)
-		})
-
-		Convey("Map section to struct", func() {
-			foobar := new(fooBar)
-			f, err := Load([]byte(_CONF_DATA_STRUCT))
-			So(err, ShouldBeNil)
-
-			So(f.Section("foo.bar").MapTo(foobar), ShouldBeNil)
-			So(foobar.Here, ShouldEqual, "there")
-			So(foobar.When, ShouldEqual, "then")
-		})
-
-		Convey("Map to non-pointer struct", func() {
-			cfg, err := Load([]byte(_CONF_DATA_STRUCT))
-			So(err, ShouldBeNil)
-			So(cfg, ShouldNotBeNil)
-
-			So(cfg.MapTo(testStruct{}), ShouldNotBeNil)
-		})
-
-		Convey("Map to unsupported type", func() {
-			cfg, err := Load([]byte(_CONF_DATA_STRUCT))
-			So(err, ShouldBeNil)
-			So(cfg, ShouldNotBeNil)
-
-			cfg.NameMapper = func(raw string) string {
-				if raw == "Byte" {
-					return "NAME"
-				}
-				return raw
-			}
-			So(cfg.MapTo(&unsupport{}), ShouldNotBeNil)
-			So(cfg.MapTo(&unsupport2{}), ShouldNotBeNil)
-			So(cfg.MapTo(&unsupport4{}), ShouldNotBeNil)
-		})
-
-		Convey("Map from invalid data source", func() {
-			So(MapTo(&testStruct{}, "hi"), ShouldNotBeNil)
-		})
-
-		Convey("Map to wrong types and gain default values", func() {
-			cfg, err := Load([]byte(_INVALID_DATA_CONF_STRUCT))
-			So(err, ShouldBeNil)
-
-			t, err := time.Parse(time.RFC3339, "1993-10-07T20:17:05Z")
-			So(err, ShouldBeNil)
-			dv := &defaultValue{"Joe", 10, true, 1.25, t, []string{"HangZhou", "Boston"}}
-			So(cfg.MapTo(dv), ShouldBeNil)
-			So(dv.Name, ShouldEqual, "Joe")
-			So(dv.Age, ShouldEqual, 10)
-			So(dv.Male, ShouldBeTrue)
-			So(dv.Money, ShouldEqual, 1.25)
-			So(dv.Born.String(), ShouldEqual, t.String())
-			So(strings.Join(dv.Cities, ","), ShouldEqual, "HangZhou,Boston")
-		})
-	})
-
-	Convey("Reflect from struct", t, func() {
-		type Embeded struct {
-			Dates  []time.Time `delim:"|"`
-			Places []string
-			None   []int
-		}
-		type Author struct {
-			Name      string `ini:"NAME"`
-			Male      bool
-			Age       int
-			GPA       float64
-			NeverMind string `ini:"-"`
-			*Embeded  `ini:"infos"`
-		}
-		a := &Author{"Unknwon", true, 21, 2.8, "",
-			&Embeded{
-				[]time.Time{time.Now(), time.Now()},
-				[]string{"HangZhou", "Boston"},
-				[]int{},
-			}}
-		cfg := Empty()
-		So(ReflectFrom(cfg, a), ShouldBeNil)
-		cfg.SaveTo("testdata/conf_reflect.ini")
-
-		Convey("Reflect from non-point struct", func() {
-			So(ReflectFrom(cfg, Author{}), ShouldNotBeNil)
-		})
-	})
-}
-
-type testMapper struct {
-	PackageName string
-}
-
-func Test_NameGetter(t *testing.T) {
-	Convey("Test name mappers", t, func() {
-		So(MapToWithMapper(&testMapper{}, TitleUnderscore, []byte("packag_name=ini")), ShouldBeNil)
-
-		cfg, err := Load([]byte("PACKAGE_NAME=ini"))
-		So(err, ShouldBeNil)
-		So(cfg, ShouldNotBeNil)
-
-		cfg.NameMapper = AllCapsUnderscore
-		tg := new(testMapper)
-		So(cfg.MapTo(tg), ShouldBeNil)
-		So(tg.PackageName, ShouldEqual, "ini")
-	})
-}
--- a/Godeps/_workspace/src/github.com/go-ini/ini/testdata/conf.ini
+++ b/Godeps/_workspace/src/github.com/go-ini/ini/testdata/conf.ini
@@ -1,2 +0,0 @@
-[author]
-E-MAIL = u@gogs.io
--- a/Godeps/_workspace/src/github.com/go-xorm/xorm/docs/images/cache_design.png
+++ b/Godeps/_workspace/src/github.com/go-xorm/xorm/docs/images/cache_design.png
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/LICENSE
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/LICENSE
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   Licensed 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.
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/command_line.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/command_line.go
@@ -1,35 +0,0 @@
-package commands
-
-import (
-	"github.com/codegangsta/cli"
-)
-
-type CommandLine interface {
-	ShowHelp()
-	ShowVersion()
-	Application() *cli.App
-	Args() cli.Args
-	Bool(name string) bool
-	Int(name string) int
-	String(name string) string
-	StringSlice(name string) []string
-	GlobalString(name string) string
-	FlagNames() (names []string)
-	Generic(name string) interface{}
-}
-
-type contextCommandLine struct {
-	*cli.Context
-}
-
-func (c *contextCommandLine) ShowHelp() {
-	cli.ShowCommandHelp(c.Context, c.Command.Name)
-}
-
-func (c *contextCommandLine) ShowVersion() {
-	cli.ShowVersion(c.Context)
-}
-
-func (c *contextCommandLine) Application() *cli.App {
-	return c.App
-}
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/commands.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/commands.go
@@ -1,48 +0,0 @@
-package commands
-
-import (
-	"github.com/codegangsta/cli"
-	"github.com/grafana/grafana-cli/pkg/log"
-)
-
-func runCommand(command func(commandLine CommandLine) error) func(context *cli.Context) {
-	return func(context *cli.Context) {
-
-		cmd := &contextCommandLine{context}
-		if err := command(cmd); err != nil {
-			log.Errorf("%v\n\n", err)
-
-			cmd.ShowHelp()
-		} else {
-			log.Info("Restart grafana after installing plugins . <service grafana-server restart>\n")
-		}
-	}
-}
-
-var Commands = []cli.Command{
-	{
-		Name:   "install",
-		Usage:  "installs stuff",
-		Action: runCommand(installCommand),
-	}, {
-		Name:   "list-remote",
-		Usage:  "list remote available plugins",
-		Action: runCommand(listremoteCommand),
-	}, {
-		Name:   "upgrade",
-		Usage:  "upgrades one plugin",
-		Action: runCommand(upgradeCommand),
-	}, {
-		Name:   "upgrade-all",
-		Usage:  "upgrades all your installed plugins",
-		Action: runCommand(upgradeAllCommand),
-	}, {
-		Name:   "ls",
-		Usage:  "list all installed plugins",
-		Action: runCommand(lsCommand),
-	}, {
-		Name:   "remove",
-		Usage:  "removes stuff",
-		Action: runCommand(removeCommand),
-	},
-}
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/commandstest/fake_commandLine.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/commandstest/fake_commandLine.go
@@ -1,95 +0,0 @@
-package commandstest
-
-import (
-	"github.com/codegangsta/cli"
-)
-
-type FakeFlagger struct {
-	Data map[string]interface{}
-}
-
-type FakeCommandLine struct {
-	LocalFlags, GlobalFlags *FakeFlagger
-	HelpShown, VersionShown bool
-	CliArgs                 []string
-}
-
-func (ff FakeFlagger) String(key string) string {
-	if value, ok := ff.Data[key]; ok {
-		return value.(string)
-	}
-	return ""
-}
-
-func (ff FakeFlagger) StringSlice(key string) []string {
-	if value, ok := ff.Data[key]; ok {
-		return value.([]string)
-	}
-	return []string{}
-}
-
-func (ff FakeFlagger) Int(key string) int {
-	if value, ok := ff.Data[key]; ok {
-		return value.(int)
-	}
-	return 0
-}
-
-func (ff FakeFlagger) Bool(key string) bool {
-	if value, ok := ff.Data[key]; ok {
-		return value.(bool)
-	}
-	return false
-}
-
-func (fcli *FakeCommandLine) String(key string) string {
-	return fcli.LocalFlags.String(key)
-}
-
-func (fcli *FakeCommandLine) StringSlice(key string) []string {
-	return fcli.LocalFlags.StringSlice(key)
-}
-
-func (fcli *FakeCommandLine) Int(key string) int {
-	return fcli.LocalFlags.Int(key)
-}
-
-func (fcli *FakeCommandLine) Bool(key string) bool {
-	if fcli.LocalFlags == nil {
-		return false
-	}
-	return fcli.LocalFlags.Bool(key)
-}
-
-func (fcli *FakeCommandLine) GlobalString(key string) string {
-	return fcli.GlobalFlags.String(key)
-}
-
-func (fcli *FakeCommandLine) Generic(name string) interface{} {
-	return fcli.LocalFlags.Data[name]
-}
-
-func (fcli *FakeCommandLine) FlagNames() []string {
-	flagNames := []string{}
-	for key := range fcli.LocalFlags.Data {
-		flagNames = append(flagNames, key)
-	}
-
-	return flagNames
-}
-
-func (fcli *FakeCommandLine) ShowHelp() {
-	fcli.HelpShown = true
-}
-
-func (fcli *FakeCommandLine) Application() *cli.App {
-	return cli.NewApp()
-}
-
-func (fcli *FakeCommandLine) Args() cli.Args {
-	return fcli.CliArgs
-}
-
-func (fcli *FakeCommandLine) ShowVersion() {
-	fcli.VersionShown = true
-}
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/commandstest/fake_ioutil.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/commandstest/fake_ioutil.go
@@ -1,55 +0,0 @@
-package commandstest
-
-import (
-	"os"
-	"time"
-)
-
-type FakeIoUtil struct {
-	FakeReadDir     []os.FileInfo
-	FakeIsDirectory bool
-}
-
-func (util *FakeIoUtil) Stat(path string) (os.FileInfo, error) {
-	return FakeFileInfo{IsDirectory: util.FakeIsDirectory}, nil
-}
-
-func (util *FakeIoUtil) RemoveAll(path string) error {
-	return nil
-}
-
-func (util *FakeIoUtil) ReadDir(path string) ([]os.FileInfo, error) {
-	return util.FakeReadDir, nil
-}
-
-func (i *FakeIoUtil) ReadFile(filename string) ([]byte, error) {
-	return make([]byte, 0), nil
-}
-
-type FakeFileInfo struct {
-	IsDirectory bool
-}
-
-func (ffi FakeFileInfo) IsDir() bool {
-	return ffi.IsDirectory
-}
-
-func (ffi FakeFileInfo) Size() int64 {
-	return 1
-}
-
-func (ffi FakeFileInfo) Mode() os.FileMode {
-	return 0777
-}
-
-func (ffi FakeFileInfo) Name() string {
-	return ""
-}
-
-func (ffi FakeFileInfo) ModTime() time.Time {
-	return time.Time{}
-}
-
-func (ffi FakeFileInfo) Sys() interface{} {
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/install_command.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/install_command.go
@@ -1,146 +0,0 @@
-package commands
-
-import (
-	"archive/zip"
-	"bytes"
-	"errors"
-	"github.com/grafana/grafana-cli/pkg/log"
-	m "github.com/grafana/grafana-cli/pkg/models"
-	services "github.com/grafana/grafana-cli/pkg/services"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path"
-	"regexp"
-)
-
-func validateInput(c CommandLine, pluginFolder string) error {
-	arg := c.Args().First()
-	if arg == "" {
-		return errors.New("please specify plugin to install")
-	}
-
-	pluginDir := c.GlobalString("path")
-	if pluginDir == "" {
-		return errors.New("missing path flag")
-	}
-
-	fileinfo, err := os.Stat(pluginDir)
-	if err != nil && !fileinfo.IsDir() {
-		return errors.New("path is not a directory")
-	}
-
-	return nil
-}
-
-func installCommand(c CommandLine) error {
-	pluginFolder := c.GlobalString("path")
-	if err := validateInput(c, pluginFolder); err != nil {
-		return err
-	}
-
-	pluginToInstall := c.Args().First()
-	version := c.Args().Get(1)
-
-	log.Infof("version: %v\n", version)
-
-	return InstallPlugin(pluginToInstall, pluginFolder, version)
-}
-
-func InstallPlugin(pluginName, pluginFolder, version string) error {
-	plugin, err := services.GetPlugin(pluginName)
-	if err != nil {
-		return err
-	}
-
-	v, err := SelectVersion(plugin, version)
-	if err != nil {
-		return err
-	}
-
-	url := v.Url
-	commit := v.Commit
-
-	downloadURL := url + "/archive/" + commit + ".zip"
-
-	log.Infof("installing %v @ %v\n", plugin.Id, version)
-	log.Infof("from url: %v\n", downloadURL)
-	log.Infof("on commit: %v\n", commit)
-	log.Infof("into: %v\n", pluginFolder)
-
-	err = downloadFile(plugin.Id, pluginFolder, downloadURL)
-	if err == nil {
-		log.Info("Installed %s successfully ✔\n", plugin.Id)
-	}
-
-	res := services.ReadPlugin(pluginFolder, pluginName)
-
-	for _, v := range res.Dependency.Plugins {
-		log.Infof("Depends on %s install!\n", v.Id)
-
-		//Todo: uncomment this code once the repo is more correct.
-		//InstallPlugin(v.Id, pluginFolder, "")
-	}
-
-	return err
-}
-
-func SelectVersion(plugin m.Plugin, version string) (m.Version, error) {
-	if version == "" {
-		return plugin.Versions[0], nil
-	}
-
-	for _, v := range plugin.Versions {
-		if v.Version == version {
-			return v, nil
-		}
-	}
-
-	return m.Version{}, errors.New("Could not find the version your looking for")
-}
-
-func RemoveGitBuildFromname(pluginname, filename string) string {
-	r := regexp.MustCompile("^[a-zA-Z0-9_.-]*/")
-	return r.ReplaceAllString(filename, pluginname+"/")
-}
-
-func downloadFile(pluginName, filepath, url string) (err error) {
-	resp, err := http.Get(url)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return err
-	}
-
-	r, err := zip.NewReader(bytes.NewReader(body), resp.ContentLength)
-	if err != nil {
-		return err
-	}
-	for _, zf := range r.File {
-		newfile := path.Join(filepath, RemoveGitBuildFromname(pluginName, zf.Name))
-
-		if zf.FileInfo().IsDir() {
-			os.Mkdir(newfile, 0777)
-		} else {
-			dst, err := os.Create(newfile)
-			if err != nil {
-				log.Errorf("%v", err)
-			}
-			defer dst.Close()
-			src, err := zf.Open()
-			if err != nil {
-				log.Errorf("%v", err)
-			}
-			defer src.Close()
-
-			io.Copy(dst, src)
-		}
-	}
-
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/listremote_command.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/listremote_command.go
@@ -1,20 +0,0 @@
-package commands
-
-import (
-	"github.com/grafana/grafana-cli/pkg/log"
-	"github.com/grafana/grafana-cli/pkg/services"
-)
-
-func listremoteCommand(c CommandLine) error {
-	plugin, err := services.ListAllPlugins()
-
-	if err != nil {
-		return err
-	}
-
-	for _, i := range plugin.Plugins {
-		log.Infof("id: %v version:\n", i.Id)
-	}
-
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/ls_command.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/ls_command.go
@@ -1,49 +0,0 @@
-package commands
-
-import (
-	"errors"
-	"github.com/grafana/grafana-cli/pkg/log"
-	m "github.com/grafana/grafana-cli/pkg/models"
-	s "github.com/grafana/grafana-cli/pkg/services"
-)
-
-var getPlugins func(path string) []m.InstalledPlugin
-
-var GetStat m.IoUtil
-
-func init() {
-	getPlugins = s.GetLocalPlugins
-	GetStat = s.IoUtil
-}
-
-func validateCommand(pluginDir string) error {
-	if pluginDir == "" {
-		return errors.New("missing path flag")
-	}
-    
-	log.Info("plugindir: " + pluginDir + "\n")
-	pluginDirInfo, err := GetStat.Stat(pluginDir)
-
-	if err != nil {
-		return errors.New("missing path flag")
-	}
-
-	if pluginDirInfo.IsDir() == false {
-		return errors.New("plugin path is not a directory")
-	}
-
-	return nil
-}
-
-func lsCommand(c CommandLine) error {
-	pluginDir := c.GlobalString("path")
-	if err := validateCommand(pluginDir); err != nil {
-		return err
-	}
-
-	for _, plugin := range getPlugins(pluginDir) {
-		log.Infof("plugin: %s @ %s \n", plugin.Name, plugin.Info.Version)
-	}
-
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/remove_command.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/remove_command.go
@@ -1,35 +0,0 @@
-package commands
-
-import (
-	"errors"
-	"github.com/grafana/grafana-cli/pkg/log"
-	m "github.com/grafana/grafana-cli/pkg/models"
-	services "github.com/grafana/grafana-cli/pkg/services"
-)
-
-var getPluginss func(path string) []m.InstalledPlugin = services.GetLocalPlugins
-var removePlugin func(pluginPath, id string) error = services.RemoveInstalledPlugin
-
-func removeCommand(c CommandLine) error {
-	pluginPath := c.GlobalString("path")
-	localPlugins := getPluginss(pluginPath)
-
-	log.Info("remove!\n")
-
-	plugin := c.Args().First()
-	log.Info("plugin: " + plugin + "\n")
-	if plugin == "" {
-		return errors.New("Missing which plugin parameter")
-	}
-
-	log.Infof("plugins : \n%v\n", localPlugins)
-
-	for _, p := range localPlugins {
-		log.Infof("is %s == %s ? %v", p.Id, c.Args().First(), p.Id == c.Args().First())
-		if p.Id == c.Args().First() {
-			removePlugin(pluginPath, p.Id)
-		}
-	}
-
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/upgrade_all_command.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/upgrade_all_command.go
@@ -1,61 +0,0 @@
-package commands
-
-import (
-	"github.com/grafana/grafana-cli/pkg/log"
-	m "github.com/grafana/grafana-cli/pkg/models"
-	services "github.com/grafana/grafana-cli/pkg/services"
-	"github.com/hashicorp/go-version"
-)
-
-func ShouldUpgrade(installed string, remote m.Plugin) bool {
-	installedVersion, err1 := version.NewVersion(installed)
-
-	if err1 != nil {
-		return false
-	}
-
-	for _, v := range remote.Versions {
-		remoteVersion, err2 := version.NewVersion(v.Version)
-
-		if err2 == nil {
-			if installedVersion.LessThan(remoteVersion) {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-func upgradeAllCommand(c CommandLine) error {
-	pluginDir := c.GlobalString("path")
-
-	localPlugins := services.GetLocalPlugins(pluginDir)
-
-	remotePlugins, err := services.ListAllPlugins()
-
-	if err != nil {
-		return err
-	}
-
-	pluginsToUpgrade := make([]m.InstalledPlugin, 0)
-
-	for _, localPlugin := range localPlugins {
-		for _, remotePlugin := range remotePlugins.Plugins {
-			if localPlugin.Id == remotePlugin.Id {
-				if ShouldUpgrade(localPlugin.Info.Version, remotePlugin) {
-					pluginsToUpgrade = append(pluginsToUpgrade, localPlugin)
-				}
-			}
-		}
-	}
-
-	for _, p := range pluginsToUpgrade {
-		log.Infof("lets upgrade %v \n", p)
-
-		services.RemoveInstalledPlugin(pluginDir, p.Id)
-		InstallPlugin(p.Id, pluginDir, "")
-	}
-
-	return nil
-}
--- a/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/upgrade_command.go
+++ b/Godeps/_workspace/src/github.com/grafana/grafana-cli/pkg/commands/upgrade_command.go
@@ -1,9 +0,0 @@
-package commands
-
-import (
-	"errors"
-)
-
-func upgradeCommand(c CommandLine) error {
-	return errors.New("Not yet Implemented")
-}
--- a/Show More
+++ b/Show More