diff --git a/.gitignore b/.gitignore
index ff0345c3cb..fff9f5c69e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,6 +27,3 @@ _testmain.go
*.swp
*~
.DS_Store
-
-# ignore vendor/
-vendor/
diff --git a/.travis.yml b/.travis.yml
index 66ee4586cf..5133a992ad 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,18 +13,11 @@ branches:
env:
global:
- - DEP_RELEASE_TAG=v0.5.0 # so the script knows which version to use
- IGNORE_BREAKING_CHANGES=true
matrix:
- GOARCH="amd64"
- GOARCH="386"
-before_install:
- - curl -sSL https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
-
-install:
- - dep ensure
-
script:
- bash rungas.sh
- grep -L -r --include *.go --exclude-dir vendor -P "Copyright (\d{4}|\(c\)) Microsoft" ./ | tee /dev/stderr | test -z "$(< /dev/stdin)"
diff --git a/Gopkg.lock b/Gopkg.lock
index 8668832cce..7a1ebcd808 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -2,15 +2,15 @@
[[projects]]
- digest = "1:e1b859e3d9e90007d5fbf25edf57733b224f1857f6592636130afab3af8cfae7"
+ digest = "1:b92928b73320648b38c93cacb9082c0fe3f8ac3383ad9bd537eef62c380e0e7a"
name = "contrib.go.opencensus.io/exporter/ocagent"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "00af367e65149ff1f2f4b93bbfbb84fd9297170d"
version = "v0.2.0"
[[projects]]
- digest = "1:f24d900a7aeff07f60d783a3e1c394e494ab119ab66278c69da9848b40626734"
+ digest = "1:8b0c2e6fd5976e77994a0174f8076b538671b14ecde5155c3efad04e006cd39b"
name = "github.com/Azure/go-autorest"
packages = [
"autorest",
@@ -24,12 +24,12 @@
"logger",
"tracing",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "f4369d4c79bf40df5e86def1e0f54c7ef261a51c"
version = "v11.5.0"
[[projects]]
- digest = "1:0b2d5839372f6dc106fcaa70b6bd5832789a633c4e470540f76c2ec6c560e1c1"
+ digest = "1:65b0d980b428a6ad4425f2df4cd5410edd81f044cf527bd1c345368444649e58"
name = "github.com/census-instrumentation/opencensus-proto"
packages = [
"gen-go/agent/common/v1",
@@ -37,40 +37,40 @@
"gen-go/resource/v1",
"gen-go/trace/v1",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "7f2434bc10da710debe5c4315ed6d4df454b4024"
version = "v0.1.0"
[[projects]]
- digest = "1:6098222470fe0172157ce9bbef5d2200df4edde17ee649c5d6e48330e4afa4c6"
+ digest = "1:76dc72490af7174349349838f2fe118996381b31ea83243812a97e5a0fd5ed55"
name = "github.com/dgrijalva/jwt-go"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "06ea1031745cb8b3dab3f6a236daf2b0aa468b7e"
version = "v3.2.0"
[[projects]]
- digest = "1:459dfcae44c32c1a6831fb99c75b40e7139aa800a04f55f6e47fedb33ee4407d"
+ digest = "1:cf0d2e435fd4ce45b789e93ef24b5f08e86be0e9807a16beb3694e2d8c9af965"
name = "github.com/dimchansky/utfbom"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "d2133a1ce379ef6fa992b0514a77146c60db9d1c"
version = "v1.1.0"
[[projects]]
branch = "master"
- digest = "1:0ab58d5d74194eee0ddf8e87c04d81180b3f3cce231f2654daad263ad2d2e3e4"
+ digest = "1:052aa482c25b2d76f432c16c4b404a6a3cb9cc205a95818c7680fcec501a43b7"
name = "github.com/dnaeon/go-vcr"
packages = [
"cassette",
"recorder",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "b3f5a17c396f1f45e232e36c6eed2577da52d22a"
[[projects]]
branch = "master"
- digest = "1:e9ffb9315dce0051beb757d0f0fc25db57c4da654efc4eada4ea109c2d9da815"
+ digest = "1:78102ee4d536347316bc42e818340cc50902e45dbd7fdd524c5a1fc0cb07b588"
name = "github.com/globalsign/mgo"
packages = [
".",
@@ -79,11 +79,11 @@
"internal/sasl",
"internal/scram",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "eeefdecb41b842af6dc652aaea4026e8403e62df"
[[projects]]
- digest = "1:3dd078fda7500c341bc26cfbc6c6a34614f295a2457149fc1045cab767cbcf18"
+ digest = "1:8f0705fa33e8957018611cc81c65cb373b626c092d39931bb86882489fc4c3f4"
name = "github.com/golang/protobuf"
packages = [
"proto",
@@ -93,7 +93,7 @@
"ptypes/timestamp",
"ptypes/wrappers",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5"
version = "v1.2.0"
@@ -101,92 +101,92 @@
digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
name = "github.com/inconshreveable/mousetrap"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
version = "v1.0"
[[projects]]
- digest = "1:3108ec0946181c60040ff51b811908f89d03e521e2b4ade5ef5c65b3c0e911ae"
+ digest = "1:ca955a9cd5b50b0f43d2cc3aeb35c951473eeca41b34eb67507f1dbcc0542394"
name = "github.com/kr/pretty"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "73f6ac0b30a98e433b289500d779f50c1a6f0712"
version = "v0.1.0"
[[projects]]
- digest = "1:11b056b4421396ab14e384ab8ab8c2079b03f1e51aa5eb4d9b81f9e0d1aa8fbf"
+ digest = "1:15b5cc79aad436d47019f814fde81a10221c740dc8ddf769221a65097fb6c2e9"
name = "github.com/kr/text"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f"
version = "v0.1.0"
[[projects]]
- digest = "1:a69ca302e0e9bab6743b40cb720ef02a8abcc2072eb55c0fd8869b3b285be425"
+ digest = "1:c78066b952f7960f7bffeb04d176e1e8d2579bd1e65067fc29f043706f11c4f3"
name = "github.com/marstr/collection"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "43f1d00df9bf332cbf8d26c3eecd6c348e92f7b3"
version = "v1.0.1"
[[projects]]
- digest = "1:f95025d583786875a71183888acc9d0987fc96f12d4f5afab3d7558797ea1c5a"
+ digest = "1:4e878df5f4e9fd625bf9c9aac77ef7cbfa4a74c01265505527c23470c0e40300"
name = "github.com/marstr/guid"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "8bd9a64bf37eb297b492a4101fb28e80ac0b290f"
version = "v1.1.0"
[[projects]]
- digest = "1:6dbb0eb72090871f2e58d1e37973fe3cb8c0f45f49459398d3fc740cb30e13bd"
+ digest = "1:5d231480e1c64a726869bc4142d270184c419749d34f167646baa21008eb0a79"
name = "github.com/mitchellh/go-homedir"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "af06845cf3004701891bf4fdb884bfe4920b3727"
version = "v1.1.0"
[[projects]]
- digest = "1:1d7e1867c49a6dd9856598ef7c3123604ea3daabf5b83f303ff457bcbc410b1d"
+ digest = "1:cf31692c14422fa27c83a05292eb5cbe0fb2775972e8f1f8446a71549bd8980b"
name = "github.com/pkg/errors"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "ba968bfe8b2f7e042a574c888954fccecfa385b4"
version = "v0.8.1"
[[projects]]
- digest = "1:7f569d906bdd20d906b606415b7d794f798f91a62fcfb6a4daa6d50690fb7a3f"
+ digest = "1:274f67cb6fed9588ea2521ecdac05a6d62a8c51c074c1fccc6a49a40ba80e925"
name = "github.com/satori/go.uuid"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3"
version = "v1.2.0"
[[projects]]
- digest = "1:615c827f6a892973a587c754ae5fad7acfc4352657aff23d0238fe0ba2a154df"
+ digest = "1:81e02c4edb639c80559c0650f9401d3e2dcc3256d1fa215382bb7c83c1db9126"
name = "github.com/shopspring/decimal"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "cd690d0c9e2447b1ef2a129a6b7b49077da89b8e"
version = "1.1.0"
[[projects]]
- digest = "1:a1403cc8a94b8d7956ee5e9694badef0e7b051af289caad1cf668331e3ffa4f6"
+ digest = "1:645cabccbb4fa8aab25a956cbcbdf6a6845ca736b2c64e197ca7cbb9d210b939"
name = "github.com/spf13/cobra"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "ef82de70bb3f60c65fb8eebacbb2d122ef517385"
version = "v0.0.3"
[[projects]]
- digest = "1:cbaf13cdbfef0e4734ed8a7504f57fe893d471d62a35b982bf6fb3f036449a66"
+ digest = "1:c1b1102241e7f645bc8e0c22ae352e8f0dc6484b6cb4d132fa9f24174e0119e2"
name = "github.com/spf13/pflag"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
version = "v1.0.3"
[[projects]]
- digest = "1:ad67dfd3799a2c58f6c65871dd141d8b53f61f600aec48ce8d7fa16a4d5476f8"
+ digest = "1:2ae8314c44cd413cfdb5b1df082b350116dd8d2fff973e62c01b285b7affd89e"
name = "go.opencensus.io"
packages = [
".",
@@ -205,24 +205,24 @@
"trace/propagation",
"trace/tracestate",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "b7bf3cdb64150a8c8c53b769fdeb2ba581bd4d4b"
version = "v0.18.0"
[[projects]]
branch = "master"
- digest = "1:10f068b4b7d1a60a6d8a877c8f1d72b7e745cf1c32aaf9eaf11e2259938f0dfb"
+ digest = "1:994c4915a59f821705d08ea77b117ec7a3e6a46cc867fd194d887500dac1c3c2"
name = "golang.org/x/crypto"
packages = [
"pkcs12",
"pkcs12/internal/rc2",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "7f87c0fbb88b590338857bcb720678c2583d4dea"
[[projects]]
branch = "master"
- digest = "1:6e31aa1a9642e3f2538b29fab83ff31395d6ae07a6778ebb86626dbf27ed33cf"
+ digest = "1:4512c74e2c934a151fa9246cdc565d29611f53295bfb05e7a6275e80ee540a0c"
name = "golang.org/x/net"
packages = [
"context",
@@ -233,27 +233,27 @@
"internal/timeseries",
"trace",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "fe579d43d83210096a79b46dcca0e3721058393a"
[[projects]]
branch = "master"
- digest = "1:814474ab808c5e04b9334d046f8a0060fc1724c2c02acfd00a7cc0008d675455"
+ digest = "1:75515eedc0dc2cb0b40372008b616fa2841d831c63eedd403285ff286c593295"
name = "golang.org/x/sync"
packages = ["semaphore"]
- pruneopts = ""
+ pruneopts = "UT"
revision = "37e7f081c4d4c64e13b10787722085407fe5d15f"
[[projects]]
branch = "master"
- digest = "1:d8c7c5e28d31494f02b25867de6827adaa90005f0ff3407f3336751fc0bc7432"
+ digest = "1:d0e9a312c4610a508569ab25e54d34600b1a96d19b1866ece104ffdf1c1b9d2c"
name = "golang.org/x/sys"
packages = ["unix"]
- pruneopts = ""
+ pruneopts = "UT"
revision = "cc5685c2db1239775905f3911f0067c0fa74762f"
[[projects]]
- digest = "1:5acd3512b047305d49e8763eef7ba423901e85d5dd2fd1e71778a0ea8de10bd4"
+ digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
name = "golang.org/x/text"
packages = [
"collate",
@@ -271,13 +271,13 @@
"unicode/norm",
"unicode/rangetable",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
version = "v0.3.0"
[[projects]]
branch = "master"
- digest = "1:6c11ba8cbd9436ba543e78dfbb8982d586c28af45af8b17b8c714465f3eff376"
+ digest = "1:f57e88c4326d5433c2f4eb28fcd1662be003cb0d11dd13710c8828e687303c76"
name = "golang.org/x/tools"
packages = [
"go/ast/astutil",
@@ -293,27 +293,27 @@
"internal/module",
"internal/semver",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "83362c3779f5f48611068d488a03ea7bbaddc81e"
[[projects]]
- digest = "1:1ef3746d0b0a2ab4147e9fe251202756ff89d181c3c3cc67abdf40e375243cbc"
+ digest = "1:5f003878aabe31d7f6b842d4de32b41c46c214bb629bb485387dbcce1edf5643"
name = "google.golang.org/api"
packages = ["support/bundler"]
- pruneopts = ""
+ pruneopts = "UT"
revision = "19e022d8cf43ce81f046bae8cc18c5397cc7732f"
version = "v0.1.0"
[[projects]]
branch = "master"
- digest = "1:58cab6380ee63ac4d983ff73b8f6aab7ab6d0cf8dc82550641017fb8e6a0940e"
+ digest = "1:077c1c599507b3b3e9156d17d36e1e61928ee9b53a5b420f10f28ebd4a0b275c"
name = "google.golang.org/genproto"
packages = ["googleapis/rpc/status"]
- pruneopts = ""
+ pruneopts = "UT"
revision = "082222b4a5c572e33e82ee9162d1352c7cf38682"
[[projects]]
- digest = "1:39d4d828b87d58d114fdc211f0638f32dcae84019fe17d6b48f9b697f4b60213"
+ digest = "1:9ab5a33d8cb5c120602a34d2e985ce17956a4e8c2edce7e6961568f95e40c09a"
name = "google.golang.org/grpc"
packages = [
".",
@@ -348,23 +348,23 @@
"status",
"tap",
]
- pruneopts = ""
+ pruneopts = "UT"
revision = "a02b0774206b209466313a0b525d2c738fe407eb"
version = "v1.18.0"
[[projects]]
branch = "v1"
- digest = "1:1d01f96bc2293b56c3dec797b8f976d7613fb30ce92bfbc994130404f7f7f031"
+ digest = "1:af715ae33cc1f5695c4b2a4e4b21d008add8802a99e15bb467ac7c32edb5000d"
name = "gopkg.in/check.v1"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "788fd78401277ebd861206a03c884797c6ec5541"
[[projects]]
- digest = "1:cedccf16b71e86db87a24f8d4c70b0a855872eb967cb906a66b95de56aefbd0d"
+ digest = "1:4d2e5a73dc1500038e504a8d78b986630e3626dc027bc030ba5c75da257cdb96"
name = "gopkg.in/yaml.v2"
packages = ["."]
- pruneopts = ""
+ pruneopts = "UT"
revision = "51d6538a90f86fe93ac480b35f37b2be17fef232"
version = "v2.2.2"
diff --git a/Gopkg.toml b/Gopkg.toml
index 84c5af8b54..c621bb40b4 100644
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -19,6 +19,9 @@
# name = "github.com/x/y"
# version = "2.4.0"
+[prune]
+ unused-packages = true
+ go-tests = true
[[constraint]]
name = "github.com/Azure/go-autorest"
diff --git a/vendor/contrib.go.opencensus.io/exporter/ocagent/.travis.yml b/vendor/contrib.go.opencensus.io/exporter/ocagent/.travis.yml
new file mode 100644
index 0000000000..192981b7f6
--- /dev/null
+++ b/vendor/contrib.go.opencensus.io/exporter/ocagent/.travis.yml
@@ -0,0 +1,17 @@
+language: go
+
+go:
+ - 1.10.x
+
+go_import_path: contrib.go.opencensus.io/exporter/ocagent
+
+before_script:
+ - GO_FILES=$(find . -iname '*.go' | grep -v /vendor/) # All the .go files, excluding vendor/ if any
+ - PKGS=$(go list ./... | grep -v /vendor/) # All the import paths, excluding vendor/ if any
+
+script:
+ - go build ./... # Ensure dependency updates don't break build
+ - if [ -n "$(gofmt -s -l $GO_FILES)" ]; then echo "gofmt the following files:"; gofmt -s -l $GO_FILES; exit 1; fi
+ - go vet ./...
+ - go test -v -race $PKGS # Run all the tests with the race detector enabled
+ - 'if [[ $TRAVIS_GO_VERSION = 1.8* ]]; then ! golint ./... | grep -vE "(_mock|_string|\.pb)\.go:"; fi'
diff --git a/vendor/contrib.go.opencensus.io/exporter/ocagent/CONTRIBUTING.md b/vendor/contrib.go.opencensus.io/exporter/ocagent/CONTRIBUTING.md
new file mode 100644
index 0000000000..0786fdf434
--- /dev/null
+++ b/vendor/contrib.go.opencensus.io/exporter/ocagent/CONTRIBUTING.md
@@ -0,0 +1,24 @@
+# How to contribute
+
+We'd love to accept your patches and contributions to this project. There are
+just a few small guidelines you need to follow.
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement. You (or your employer) retain the copyright to your contribution,
+this simply gives us permission to use and redistribute your contributions as
+part of the project. Head over to to see
+your current agreements on file or to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Code reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult [GitHub Help] for more
+information on using pull requests.
+
+[GitHub Help]: https://help.github.com/articles/about-pull-requests/
diff --git a/vendor/contrib.go.opencensus.io/exporter/ocagent/LICENSE b/vendor/contrib.go.opencensus.io/exporter/ocagent/LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/vendor/contrib.go.opencensus.io/exporter/ocagent/LICENSE
@@ -0,0 +1,201 @@
+ 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.
diff --git a/vendor/contrib.go.opencensus.io/exporter/ocagent/README.md b/vendor/contrib.go.opencensus.io/exporter/ocagent/README.md
new file mode 100644
index 0000000000..64550ee609
--- /dev/null
+++ b/vendor/contrib.go.opencensus.io/exporter/ocagent/README.md
@@ -0,0 +1,61 @@
+# OpenCensus Agent Go Exporter
+
+[![Build Status][travis-image]][travis-url] [![GoDoc][godoc-image]][godoc-url]
+
+
+This repository contains the Go implementation of the OpenCensus Agent (OC-Agent) Exporter.
+OC-Agent is a deamon process running in a VM that can retrieve spans/stats/metrics from
+OpenCensus Library, export them to other backends and possibly push configurations back to
+Library. See more details on [OC-Agent Readme][OCAgentReadme].
+
+Note: This is an experimental repository and is likely to get backwards-incompatible changes.
+Ultimately we may want to move the OC-Agent Go Exporter to [OpenCensus Go core library][OpenCensusGo].
+
+## Installation
+
+```bash
+$ go get -u contrib.go.opencensus.io/exporter/ocagent/v1
+```
+
+## Usage
+
+```go
+import (
+ "context"
+ "fmt"
+ "log"
+ "time"
+
+ "contrib.go.opencensus.io/exporter/ocagent/v1"
+ "go.opencensus.io/trace"
+)
+
+func Example() {
+ exp, err := ocagent.NewExporter(ocagent.WithInsecure(), ocagent.WithServiceName("your-service-name"))
+ if err != nil {
+ log.Fatalf("Failed to create the agent exporter: %v", err)
+ }
+ defer exp.Stop()
+
+ // Now register it as a trace exporter.
+ trace.RegisterExporter(exp)
+
+ // Then use the OpenCensus tracing library, like we normally would.
+ ctx, span := trace.StartSpan(context.Background(), "AgentExporter-Example")
+ defer span.End()
+
+ for i := 0; i < 10; i++ {
+ _, iSpan := trace.StartSpan(ctx, fmt.Sprintf("Sample-%d", i))
+ <-time.After(6 * time.Millisecond)
+ iSpan.End()
+ }
+}
+```
+
+[OCAgentReadme]: https://github.com/census-instrumentation/opencensus-proto/tree/master/opencensus/proto/agent#opencensus-agent-proto
+[OpenCensusGo]: https://github.com/census-instrumentation/opencensus-go
+[godoc-image]: https://godoc.org/contrib.go.opencensus.io/exporter/ocagent?status.svg
+[godoc-url]: https://godoc.org/contrib.go.opencensus.io/exporter/ocagent
+[travis-image]: https://travis-ci.org/census-ecosystem/opencensus-go-exporter-ocagent.svg?branch=master
+[travis-url]: https://travis-ci.org/census-ecosystem/opencensus-go-exporter-ocagent
+
diff --git a/vendor/contrib.go.opencensus.io/exporter/ocagent/common.go b/vendor/contrib.go.opencensus.io/exporter/ocagent/common.go
new file mode 100644
index 0000000000..297e44b6e7
--- /dev/null
+++ b/vendor/contrib.go.opencensus.io/exporter/ocagent/common.go
@@ -0,0 +1,38 @@
+// Copyright 2018, OpenCensus Authors
+//
+// 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 ocagent
+
+import (
+ "math/rand"
+ "time"
+)
+
+var randSrc = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+// retries function fn upto n times, if fn returns an error lest it returns nil early.
+// It applies exponential backoff in units of (1< 0 {
+ port = ae.agentPort
+ }
+ return fmt.Sprintf("%s:%d", DefaultAgentHost, port)
+}
+
+func (ae *Exporter) doStartLocked() error {
+ if ae.started {
+ return nil
+ }
+
+ // Now start it
+ cc, err := ae.dialToAgent()
+ if err != nil {
+ return err
+ }
+ ae.grpcClientConn = cc
+
+ // Initiate the trace service by sending over node identifier info.
+ traceSvcClient := agenttracepb.NewTraceServiceClient(cc)
+ traceExporter, err := traceSvcClient.Export(context.Background())
+ if err != nil {
+ return fmt.Errorf("Exporter.Start:: TraceServiceClient: %v", err)
+ }
+
+ firstTraceMessage := &agenttracepb.ExportTraceServiceRequest{Node: ae.nodeInfo}
+ err = nTriesWithExponentialBackoff(maxInitialTracesRetries, 200*time.Microsecond, func() error {
+ return traceExporter.Send(firstTraceMessage)
+ })
+ if err != nil {
+ return fmt.Errorf("Exporter.Start:: Failed to initiate the Config service: %v", err)
+ }
+ ae.traceExporter = traceExporter
+
+ // Initiate the config service by sending over node identifier info.
+ configStream, err := traceSvcClient.Config(context.Background())
+ if err != nil {
+ return fmt.Errorf("Exporter.Start:: ConfigStream: %v", err)
+ }
+ firstCfgMessage := &agenttracepb.CurrentLibraryConfig{Node: ae.nodeInfo}
+ err = nTriesWithExponentialBackoff(maxInitialConfigRetries, 200*time.Microsecond, func() error {
+ return configStream.Send(firstCfgMessage)
+ })
+ if err != nil {
+ return fmt.Errorf("Exporter.Start:: Failed to initiate the Config service: %v", err)
+ }
+
+ // In the background, handle trace configurations that are beamed down
+ // by the agent, but also reply to it with the applied configuration.
+ go ae.handleConfigStreaming(configStream)
+
+ return nil
+}
+
+// dialToAgent performs a best case attempt to dial to the agent.
+// It retries failed dials with:
+// * gRPC dialTimeout of 1s
+// * exponential backoff, 5 times with a period of 50ms
+// hence in the worst case of (no agent actually available), it
+// will take at least:
+// (5 * 1s) + ((1<<5)-1) * 0.01 s = 5s + 1.55s = 6.55s
+func (ae *Exporter) dialToAgent() (*grpc.ClientConn, error) {
+ addr := ae.prepareAgentAddress()
+ dialOpts := []grpc.DialOption{grpc.WithBlock()}
+ if ae.canDialInsecure {
+ dialOpts = append(dialOpts, grpc.WithInsecure())
+ }
+
+ var cc *grpc.ClientConn
+ dialOpts = append(dialOpts, grpc.WithTimeout(1*time.Second))
+ dialBackoffWaitPeriod := 50 * time.Millisecond
+ err := nTriesWithExponentialBackoff(5, dialBackoffWaitPeriod, func() error {
+ var err error
+ cc, err = grpc.Dial(addr, dialOpts...)
+ return err
+ })
+ return cc, err
+}
+
+func (ae *Exporter) handleConfigStreaming(configStream agenttracepb.TraceService_ConfigClient) error {
+ for {
+ recv, err := configStream.Recv()
+ if err != nil {
+ // TODO: Check if this is a transient error or exponential backoff-able.
+ return err
+ }
+ cfg := recv.Config
+ if cfg == nil {
+ continue
+ }
+
+ // Otherwise now apply the trace configuration sent down from the agent
+ if psamp := cfg.GetProbabilitySampler(); psamp != nil {
+ trace.ApplyConfig(trace.Config{DefaultSampler: trace.ProbabilitySampler(psamp.SamplingProbability)})
+ } else if csamp := cfg.GetConstantSampler(); csamp != nil {
+ alwaysSample := csamp.Decision == true
+ if alwaysSample {
+ trace.ApplyConfig(trace.Config{DefaultSampler: trace.AlwaysSample()})
+ } else {
+ trace.ApplyConfig(trace.Config{DefaultSampler: trace.NeverSample()})
+ }
+ } else { // TODO: Add the rate limiting sampler here
+ }
+
+ // Then finally send back to upstream the newly applied configuration
+ err = configStream.Send(&agenttracepb.CurrentLibraryConfig{Config: &tracepb.TraceConfig{Sampler: cfg.Sampler}})
+ if err != nil {
+ return err
+ }
+ }
+}
+
+var (
+ errNotStarted = errors.New("not started")
+)
+
+// Stop shuts down all the connections and resources
+// related to the exporter.
+func (ae *Exporter) Stop() error {
+ ae.mu.Lock()
+ defer ae.mu.Unlock()
+
+ if !ae.started {
+ return errNotStarted
+ }
+ if ae.stopped {
+ // TODO: tell the user that we've already stopped, so perhaps a sentinel error?
+ return nil
+ }
+
+ ae.Flush()
+
+ // Now close the underlying gRPC connection.
+ var err error
+ if ae.grpcClientConn != nil {
+ err = ae.grpcClientConn.Close()
+ }
+
+ // At this point we can change the state variables: started and stopped
+ ae.started = false
+ ae.stopped = true
+
+ return err
+}
+
+func (ae *Exporter) ExportSpan(sd *trace.SpanData) {
+ if sd == nil {
+ return
+ }
+ _ = ae.traceBundler.Add(sd, -1)
+}
+
+func (ae *Exporter) uploadTraces(sdl []*trace.SpanData) {
+ if len(sdl) == 0 {
+ return
+ }
+ protoSpans := make([]*tracepb.Span, 0, len(sdl))
+ for _, sd := range sdl {
+ if sd != nil {
+ protoSpans = append(protoSpans, ocSpanToProtoSpan(sd))
+ }
+ }
+
+ if len(protoSpans) > 0 {
+ _ = ae.traceExporter.Send(&agenttracepb.ExportTraceServiceRequest{
+ Spans: protoSpans,
+ })
+ }
+}
+
+func (ae *Exporter) Flush() {
+ ae.traceBundler.Flush()
+}
diff --git a/vendor/contrib.go.opencensus.io/exporter/ocagent/options.go b/vendor/contrib.go.opencensus.io/exporter/ocagent/options.go
new file mode 100644
index 0000000000..751f311f1f
--- /dev/null
+++ b/vendor/contrib.go.opencensus.io/exporter/ocagent/options.go
@@ -0,0 +1,80 @@
+// Copyright 2018, OpenCensus Authors
+//
+// 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 ocagent
+
+const (
+ DefaultAgentPort uint16 = 55678
+ DefaultAgentHost string = "localhost"
+)
+
+type ExporterOption interface {
+ withExporter(e *Exporter)
+}
+
+type portSetter uint16
+
+func (ps portSetter) withExporter(e *Exporter) {
+ e.agentPort = uint16(ps)
+}
+
+var _ ExporterOption = (*portSetter)(nil)
+
+type insecureGrpcConnection int
+
+var _ ExporterOption = (*insecureGrpcConnection)(nil)
+
+func (igc *insecureGrpcConnection) withExporter(e *Exporter) {
+ e.canDialInsecure = true
+}
+
+// WithInsecure disables client transport security for the exporter's gRPC connection
+// just like grpc.WithInsecure() https://godoc.org/google.golang.org/grpc#WithInsecure
+// does. Note, by default, client security is required unless WithInsecure is used.
+func WithInsecure() ExporterOption { return new(insecureGrpcConnection) }
+
+// WithPort allows one to override the port that the exporter will
+// connect to the agent on, instead of using DefaultAgentPort.
+func WithPort(port uint16) ExporterOption {
+ return portSetter(port)
+}
+
+type addressSetter string
+
+func (as addressSetter) withExporter(e *Exporter) {
+ e.agentAddress = string(as)
+}
+
+var _ ExporterOption = (*addressSetter)(nil)
+
+// WithAddress allows one to set the address that the exporter will
+// connect to the agent on. If unset, it will instead try to use
+// connect to DefaultAgentHost:DefaultAgentPort
+func WithAddress(addr string) ExporterOption {
+ return addressSetter(addr)
+}
+
+type serviceNameSetter string
+
+func (sns serviceNameSetter) withExporter(e *Exporter) {
+ e.serviceName = string(sns)
+}
+
+var _ ExporterOption = (*serviceNameSetter)(nil)
+
+// WithServiceName allows one to set/override the service name
+// that the exporter will report to the agent.
+func WithServiceName(serviceName string) ExporterOption {
+ return serviceNameSetter(serviceName)
+}
diff --git a/vendor/contrib.go.opencensus.io/exporter/ocagent/transform_spans.go b/vendor/contrib.go.opencensus.io/exporter/ocagent/transform_spans.go
new file mode 100644
index 0000000000..ba7b51d206
--- /dev/null
+++ b/vendor/contrib.go.opencensus.io/exporter/ocagent/transform_spans.go
@@ -0,0 +1,162 @@
+// Copyright 2018, OpenCensus Authors
+//
+// 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 ocagent
+
+import (
+ "time"
+
+ "go.opencensus.io/trace"
+ "go.opencensus.io/trace/tracestate"
+
+ tracepb "github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1"
+ "github.com/golang/protobuf/ptypes/timestamp"
+)
+
+func ocSpanToProtoSpan(sd *trace.SpanData) *tracepb.Span {
+ if sd == nil {
+ return nil
+ }
+ var namePtr *tracepb.TruncatableString
+ if sd.Name != "" {
+ namePtr = &tracepb.TruncatableString{Value: sd.Name}
+ }
+ return &tracepb.Span{
+ TraceId: sd.TraceID[:],
+ SpanId: sd.SpanID[:],
+ ParentSpanId: sd.ParentSpanID[:],
+ Status: ocStatusToProtoStatus(sd.Status),
+ StartTime: timeToTimestamp(sd.StartTime),
+ EndTime: timeToTimestamp(sd.EndTime),
+ Links: ocLinksToProtoLinks(sd.Links),
+ Kind: ocSpanKindToProtoSpanKind(sd.SpanKind),
+ Name: namePtr,
+ Attributes: ocAttributesToProtoAttributes(sd.Attributes),
+ Tracestate: ocTracestateToProtoTracestate(sd.Tracestate),
+ }
+}
+
+var blankStatus trace.Status
+
+func ocStatusToProtoStatus(status trace.Status) *tracepb.Status {
+ if status == blankStatus {
+ return nil
+ }
+ return &tracepb.Status{
+ Code: status.Code,
+ Message: status.Message,
+ }
+}
+
+func ocLinksToProtoLinks(links []trace.Link) *tracepb.Span_Links {
+ if len(links) == 0 {
+ return nil
+ }
+
+ sl := make([]*tracepb.Span_Link, 0, len(links))
+ for _, ocLink := range links {
+ // This redefinition is necessary to prevent ocLink.*ID[:] copies
+ // being reused -- in short we need a new ocLink per iteration.
+ ocLink := ocLink
+
+ sl = append(sl, &tracepb.Span_Link{
+ TraceId: ocLink.TraceID[:],
+ SpanId: ocLink.SpanID[:],
+ Type: ocLinkTypeToProtoLinkType(ocLink.Type),
+ })
+ }
+
+ return &tracepb.Span_Links{
+ Link: sl,
+ }
+}
+
+func ocLinkTypeToProtoLinkType(oct trace.LinkType) tracepb.Span_Link_Type {
+ switch oct {
+ case trace.LinkTypeChild:
+ return tracepb.Span_Link_CHILD_LINKED_SPAN
+ case trace.LinkTypeParent:
+ return tracepb.Span_Link_PARENT_LINKED_SPAN
+ default:
+ return tracepb.Span_Link_TYPE_UNSPECIFIED
+ }
+}
+
+func ocAttributesToProtoAttributes(attrs map[string]interface{}) *tracepb.Span_Attributes {
+ if len(attrs) == 0 {
+ return nil
+ }
+ outMap := make(map[string]*tracepb.AttributeValue)
+ for k, v := range attrs {
+ switch v := v.(type) {
+ case bool:
+ outMap[k] = &tracepb.AttributeValue{Value: &tracepb.AttributeValue_BoolValue{BoolValue: v}}
+
+ case int:
+ outMap[k] = &tracepb.AttributeValue{Value: &tracepb.AttributeValue_IntValue{IntValue: int64(v)}}
+
+ case int64:
+ outMap[k] = &tracepb.AttributeValue{Value: &tracepb.AttributeValue_IntValue{IntValue: v}}
+
+ case string:
+ outMap[k] = &tracepb.AttributeValue{
+ Value: &tracepb.AttributeValue_StringValue{
+ StringValue: &tracepb.TruncatableString{Value: v},
+ },
+ }
+ }
+ }
+ return &tracepb.Span_Attributes{
+ AttributeMap: outMap,
+ }
+}
+
+func timeToTimestamp(t time.Time) *timestamp.Timestamp {
+ nanoTime := t.UnixNano()
+ return ×tamp.Timestamp{
+ Seconds: nanoTime / 1e9,
+ Nanos: int32(nanoTime % 1e9),
+ }
+}
+
+func ocSpanKindToProtoSpanKind(kind int) tracepb.Span_SpanKind {
+ switch kind {
+ case trace.SpanKindClient:
+ return tracepb.Span_CLIENT
+ case trace.SpanKindServer:
+ return tracepb.Span_SERVER
+ default:
+ return tracepb.Span_SPAN_KIND_UNSPECIFIED
+ }
+}
+
+func ocTracestateToProtoTracestate(ts *tracestate.Tracestate) *tracepb.Span_Tracestate {
+ if ts == nil {
+ return nil
+ }
+ return &tracepb.Span_Tracestate{
+ Entries: ocTracestateEntriesToProtoTracestateEntries(ts.Entries()),
+ }
+}
+
+func ocTracestateEntriesToProtoTracestateEntries(entries []tracestate.Entry) []*tracepb.Span_Tracestate_Entry {
+ protoEntries := make([]*tracepb.Span_Tracestate_Entry, 0, len(entries))
+ for _, entry := range entries {
+ protoEntries = append(protoEntries, &tracepb.Span_Tracestate_Entry{
+ Key: entry.Key,
+ Value: entry.Value,
+ })
+ }
+ return protoEntries
+}
diff --git a/vendor/contrib.go.opencensus.io/exporter/ocagent/version.go b/vendor/contrib.go.opencensus.io/exporter/ocagent/version.go
new file mode 100644
index 0000000000..68be4c75bd
--- /dev/null
+++ b/vendor/contrib.go.opencensus.io/exporter/ocagent/version.go
@@ -0,0 +1,17 @@
+// Copyright 2018, OpenCensus Authors
+//
+// 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 ocagent
+
+const Version = "0.0.1"
diff --git a/vendor/github.com/Azure/go-autorest/LICENSE b/vendor/github.com/Azure/go-autorest/LICENSE
new file mode 100644
index 0000000000..b9d6a27ea9
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/LICENSE
@@ -0,0 +1,191 @@
+
+ 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
+
+ Copyright 2015 Microsoft Corporation
+
+ 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.
diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/README.md b/vendor/github.com/Azure/go-autorest/autorest/adal/README.md
new file mode 100644
index 0000000000..7b0c4bc4d2
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/adal/README.md
@@ -0,0 +1,292 @@
+# Azure Active Directory authentication for Go
+
+This is a standalone package for authenticating with Azure Active
+Directory from other Go libraries and applications, in particular the [Azure SDK
+for Go](https://github.com/Azure/azure-sdk-for-go).
+
+Note: Despite the package's name it is not related to other "ADAL" libraries
+maintained in the [github.com/AzureAD](https://github.com/AzureAD) org. Issues
+should be opened in [this repo's](https://github.com/Azure/go-autorest/issues)
+or [the SDK's](https://github.com/Azure/azure-sdk-for-go/issues) issue
+trackers.
+
+## Install
+
+```bash
+go get -u github.com/Azure/go-autorest/autorest/adal
+```
+
+## Usage
+
+An Active Directory application is required in order to use this library. An application can be registered in the [Azure Portal](https://portal.azure.com/) by following these [guidelines](https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-integrating-applications) or using the [Azure CLI](https://github.com/Azure/azure-cli).
+
+### Register an Azure AD Application with secret
+
+
+1. Register a new application with a `secret` credential
+
+ ```
+ az ad app create \
+ --display-name example-app \
+ --homepage https://example-app/home \
+ --identifier-uris https://example-app/app \
+ --password secret
+ ```
+
+2. Create a service principal using the `Application ID` from previous step
+
+ ```
+ az ad sp create --id "Application ID"
+ ```
+
+ * Replace `Application ID` with `appId` from step 1.
+
+### Register an Azure AD Application with certificate
+
+1. Create a private key
+
+ ```
+ openssl genrsa -out "example-app.key" 2048
+ ```
+
+2. Create the certificate
+
+ ```
+ openssl req -new -key "example-app.key" -subj "/CN=example-app" -out "example-app.csr"
+ openssl x509 -req -in "example-app.csr" -signkey "example-app.key" -out "example-app.crt" -days 10000
+ ```
+
+3. Create the PKCS12 version of the certificate containing also the private key
+
+ ```
+ openssl pkcs12 -export -out "example-app.pfx" -inkey "example-app.key" -in "example-app.crt" -passout pass:
+
+ ```
+
+4. Register a new application with the certificate content form `example-app.crt`
+
+ ```
+ certificateContents="$(tail -n+2 "example-app.crt" | head -n-1)"
+
+ az ad app create \
+ --display-name example-app \
+ --homepage https://example-app/home \
+ --identifier-uris https://example-app/app \
+ --key-usage Verify --end-date 2018-01-01 \
+ --key-value "${certificateContents}"
+ ```
+
+5. Create a service principal using the `Application ID` from previous step
+
+ ```
+ az ad sp create --id "APPLICATION_ID"
+ ```
+
+ * Replace `APPLICATION_ID` with `appId` from step 4.
+
+
+### Grant the necessary permissions
+
+Azure relies on a Role-Based Access Control (RBAC) model to manage the access to resources at a fine-grained
+level. There is a set of [pre-defined roles](https://docs.microsoft.com/en-us/azure/active-directory/role-based-access-built-in-roles)
+which can be assigned to a service principal of an Azure AD application depending of your needs.
+
+```
+az role assignment create --assigner "SERVICE_PRINCIPAL_ID" --role "ROLE_NAME"
+```
+
+* Replace the `SERVICE_PRINCIPAL_ID` with the `appId` from previous step.
+* Replace the `ROLE_NAME` with a role name of your choice.
+
+It is also possible to define custom role definitions.
+
+```
+az role definition create --role-definition role-definition.json
+```
+
+* Check [custom roles](https://docs.microsoft.com/en-us/azure/active-directory/role-based-access-control-custom-roles) for more details regarding the content of `role-definition.json` file.
+
+
+### Acquire Access Token
+
+The common configuration used by all flows:
+
+```Go
+const activeDirectoryEndpoint = "https://login.microsoftonline.com/"
+tenantID := "TENANT_ID"
+oauthConfig, err := adal.NewOAuthConfig(activeDirectoryEndpoint, tenantID)
+
+applicationID := "APPLICATION_ID"
+
+callback := func(token adal.Token) error {
+ // This is called after the token is acquired
+}
+
+// The resource for which the token is acquired
+resource := "https://management.core.windows.net/"
+```
+
+* Replace the `TENANT_ID` with your tenant ID.
+* Replace the `APPLICATION_ID` with the value from previous section.
+
+#### Client Credentials
+
+```Go
+applicationSecret := "APPLICATION_SECRET"
+
+spt, err := adal.NewServicePrincipalToken(
+ oauthConfig,
+ appliationID,
+ applicationSecret,
+ resource,
+ callbacks...)
+if err != nil {
+ return nil, err
+}
+
+// Acquire a new access token
+err = spt.Refresh()
+if (err == nil) {
+ token := spt.Token
+}
+```
+
+* Replace the `APPLICATION_SECRET` with the `password` value from previous section.
+
+#### Client Certificate
+
+```Go
+certificatePath := "./example-app.pfx"
+
+certData, err := ioutil.ReadFile(certificatePath)
+if err != nil {
+ return nil, fmt.Errorf("failed to read the certificate file (%s): %v", certificatePath, err)
+}
+
+// Get the certificate and private key from pfx file
+certificate, rsaPrivateKey, err := decodePkcs12(certData, "")
+if err != nil {
+ return nil, fmt.Errorf("failed to decode pkcs12 certificate while creating spt: %v", err)
+}
+
+spt, err := adal.NewServicePrincipalTokenFromCertificate(
+ oauthConfig,
+ applicationID,
+ certificate,
+ rsaPrivateKey,
+ resource,
+ callbacks...)
+
+// Acquire a new access token
+err = spt.Refresh()
+if (err == nil) {
+ token := spt.Token
+}
+```
+
+* Update the certificate path to point to the example-app.pfx file which was created in previous section.
+
+
+#### Device Code
+
+```Go
+oauthClient := &http.Client{}
+
+// Acquire the device code
+deviceCode, err := adal.InitiateDeviceAuth(
+ oauthClient,
+ oauthConfig,
+ applicationID,
+ resource)
+if err != nil {
+ return nil, fmt.Errorf("Failed to start device auth flow: %s", err)
+}
+
+// Display the authentication message
+fmt.Println(*deviceCode.Message)
+
+// Wait here until the user is authenticated
+token, err := adal.WaitForUserCompletion(oauthClient, deviceCode)
+if err != nil {
+ return nil, fmt.Errorf("Failed to finish device auth flow: %s", err)
+}
+
+spt, err := adal.NewServicePrincipalTokenFromManualToken(
+ oauthConfig,
+ applicationID,
+ resource,
+ *token,
+ callbacks...)
+
+if (err == nil) {
+ token := spt.Token
+}
+```
+
+#### Username password authenticate
+
+```Go
+spt, err := adal.NewServicePrincipalTokenFromUsernamePassword(
+ oauthConfig,
+ applicationID,
+ username,
+ password,
+ resource,
+ callbacks...)
+
+if (err == nil) {
+ token := spt.Token
+}
+```
+
+#### Authorization code authenticate
+
+``` Go
+spt, err := adal.NewServicePrincipalTokenFromAuthorizationCode(
+ oauthConfig,
+ applicationID,
+ clientSecret,
+ authorizationCode,
+ redirectURI,
+ resource,
+ callbacks...)
+
+err = spt.Refresh()
+if (err == nil) {
+ token := spt.Token
+}
+```
+
+### Command Line Tool
+
+A command line tool is available in `cmd/adal.go` that can acquire a token for a given resource. It supports all flows mentioned above.
+
+```
+adal -h
+
+Usage of ./adal:
+ -applicationId string
+ application id
+ -certificatePath string
+ path to pk12/PFC application certificate
+ -mode string
+ authentication mode (device, secret, cert, refresh) (default "device")
+ -resource string
+ resource for which the token is requested
+ -secret string
+ application secret
+ -tenantId string
+ tenant id
+ -tokenCachePath string
+ location of oath token cache (default "/home/cgc/.adal/accessToken.json")
+```
+
+Example acquire a token for `https://management.core.windows.net/` using device code flow:
+
+```
+adal -mode device \
+ -applicationId "APPLICATION_ID" \
+ -tenantId "TENANT_ID" \
+ -resource https://management.core.windows.net/
+
+```
diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/config.go b/vendor/github.com/Azure/go-autorest/autorest/adal/config.go
new file mode 100644
index 0000000000..8c83a917ff
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/adal/config.go
@@ -0,0 +1,91 @@
+package adal
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "fmt"
+ "net/url"
+)
+
+// OAuthConfig represents the endpoints needed
+// in OAuth operations
+type OAuthConfig struct {
+ AuthorityEndpoint url.URL `json:"authorityEndpoint"`
+ AuthorizeEndpoint url.URL `json:"authorizeEndpoint"`
+ TokenEndpoint url.URL `json:"tokenEndpoint"`
+ DeviceCodeEndpoint url.URL `json:"deviceCodeEndpoint"`
+}
+
+// IsZero returns true if the OAuthConfig object is zero-initialized.
+func (oac OAuthConfig) IsZero() bool {
+ return oac == OAuthConfig{}
+}
+
+func validateStringParam(param, name string) error {
+ if len(param) == 0 {
+ return fmt.Errorf("parameter '" + name + "' cannot be empty")
+ }
+ return nil
+}
+
+// NewOAuthConfig returns an OAuthConfig with tenant specific urls
+func NewOAuthConfig(activeDirectoryEndpoint, tenantID string) (*OAuthConfig, error) {
+ apiVer := "1.0"
+ return NewOAuthConfigWithAPIVersion(activeDirectoryEndpoint, tenantID, &apiVer)
+}
+
+// NewOAuthConfigWithAPIVersion returns an OAuthConfig with tenant specific urls.
+// If apiVersion is not nil the "api-version" query parameter will be appended to the endpoint URLs with the specified value.
+func NewOAuthConfigWithAPIVersion(activeDirectoryEndpoint, tenantID string, apiVersion *string) (*OAuthConfig, error) {
+ if err := validateStringParam(activeDirectoryEndpoint, "activeDirectoryEndpoint"); err != nil {
+ return nil, err
+ }
+ api := ""
+ // it's legal for tenantID to be empty so don't validate it
+ if apiVersion != nil {
+ if err := validateStringParam(*apiVersion, "apiVersion"); err != nil {
+ return nil, err
+ }
+ api = fmt.Sprintf("?api-version=%s", *apiVersion)
+ }
+ const activeDirectoryEndpointTemplate = "%s/oauth2/%s%s"
+ u, err := url.Parse(activeDirectoryEndpoint)
+ if err != nil {
+ return nil, err
+ }
+ authorityURL, err := u.Parse(tenantID)
+ if err != nil {
+ return nil, err
+ }
+ authorizeURL, err := u.Parse(fmt.Sprintf(activeDirectoryEndpointTemplate, tenantID, "authorize", api))
+ if err != nil {
+ return nil, err
+ }
+ tokenURL, err := u.Parse(fmt.Sprintf(activeDirectoryEndpointTemplate, tenantID, "token", api))
+ if err != nil {
+ return nil, err
+ }
+ deviceCodeURL, err := u.Parse(fmt.Sprintf(activeDirectoryEndpointTemplate, tenantID, "devicecode", api))
+ if err != nil {
+ return nil, err
+ }
+
+ return &OAuthConfig{
+ AuthorityEndpoint: *authorityURL,
+ AuthorizeEndpoint: *authorizeURL,
+ TokenEndpoint: *tokenURL,
+ DeviceCodeEndpoint: *deviceCodeURL,
+ }, nil
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go b/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go
new file mode 100644
index 0000000000..b38f4c2458
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go
@@ -0,0 +1,242 @@
+package adal
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+/*
+ This file is largely based on rjw57/oauth2device's code, with the follow differences:
+ * scope -> resource, and only allow a single one
+ * receive "Message" in the DeviceCode struct and show it to users as the prompt
+ * azure-xplat-cli has the following behavior that this emulates:
+ - does not send client_secret during the token exchange
+ - sends resource again in the token exchange request
+*/
+
+import (
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+)
+
+const (
+ logPrefix = "autorest/adal/devicetoken:"
+)
+
+var (
+ // ErrDeviceGeneric represents an unknown error from the token endpoint when using device flow
+ ErrDeviceGeneric = fmt.Errorf("%s Error while retrieving OAuth token: Unknown Error", logPrefix)
+
+ // ErrDeviceAccessDenied represents an access denied error from the token endpoint when using device flow
+ ErrDeviceAccessDenied = fmt.Errorf("%s Error while retrieving OAuth token: Access Denied", logPrefix)
+
+ // ErrDeviceAuthorizationPending represents the server waiting on the user to complete the device flow
+ ErrDeviceAuthorizationPending = fmt.Errorf("%s Error while retrieving OAuth token: Authorization Pending", logPrefix)
+
+ // ErrDeviceCodeExpired represents the server timing out and expiring the code during device flow
+ ErrDeviceCodeExpired = fmt.Errorf("%s Error while retrieving OAuth token: Code Expired", logPrefix)
+
+ // ErrDeviceSlowDown represents the service telling us we're polling too often during device flow
+ ErrDeviceSlowDown = fmt.Errorf("%s Error while retrieving OAuth token: Slow Down", logPrefix)
+
+ // ErrDeviceCodeEmpty represents an empty device code from the device endpoint while using device flow
+ ErrDeviceCodeEmpty = fmt.Errorf("%s Error while retrieving device code: Device Code Empty", logPrefix)
+
+ // ErrOAuthTokenEmpty represents an empty OAuth token from the token endpoint when using device flow
+ ErrOAuthTokenEmpty = fmt.Errorf("%s Error while retrieving OAuth token: Token Empty", logPrefix)
+
+ errCodeSendingFails = "Error occurred while sending request for Device Authorization Code"
+ errCodeHandlingFails = "Error occurred while handling response from the Device Endpoint"
+ errTokenSendingFails = "Error occurred while sending request with device code for a token"
+ errTokenHandlingFails = "Error occurred while handling response from the Token Endpoint (during device flow)"
+ errStatusNotOK = "Error HTTP status != 200"
+)
+
+// DeviceCode is the object returned by the device auth endpoint
+// It contains information to instruct the user to complete the auth flow
+type DeviceCode struct {
+ DeviceCode *string `json:"device_code,omitempty"`
+ UserCode *string `json:"user_code,omitempty"`
+ VerificationURL *string `json:"verification_url,omitempty"`
+ ExpiresIn *int64 `json:"expires_in,string,omitempty"`
+ Interval *int64 `json:"interval,string,omitempty"`
+
+ Message *string `json:"message"` // Azure specific
+ Resource string // store the following, stored when initiating, used when exchanging
+ OAuthConfig OAuthConfig
+ ClientID string
+}
+
+// TokenError is the object returned by the token exchange endpoint
+// when something is amiss
+type TokenError struct {
+ Error *string `json:"error,omitempty"`
+ ErrorCodes []int `json:"error_codes,omitempty"`
+ ErrorDescription *string `json:"error_description,omitempty"`
+ Timestamp *string `json:"timestamp,omitempty"`
+ TraceID *string `json:"trace_id,omitempty"`
+}
+
+// DeviceToken is the object return by the token exchange endpoint
+// It can either look like a Token or an ErrorToken, so put both here
+// and check for presence of "Error" to know if we are in error state
+type deviceToken struct {
+ Token
+ TokenError
+}
+
+// InitiateDeviceAuth initiates a device auth flow. It returns a DeviceCode
+// that can be used with CheckForUserCompletion or WaitForUserCompletion.
+func InitiateDeviceAuth(sender Sender, oauthConfig OAuthConfig, clientID, resource string) (*DeviceCode, error) {
+ v := url.Values{
+ "client_id": []string{clientID},
+ "resource": []string{resource},
+ }
+
+ s := v.Encode()
+ body := ioutil.NopCloser(strings.NewReader(s))
+
+ req, err := http.NewRequest(http.MethodPost, oauthConfig.DeviceCodeEndpoint.String(), body)
+ if err != nil {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errCodeSendingFails, err.Error())
+ }
+
+ req.ContentLength = int64(len(s))
+ req.Header.Set(contentType, mimeTypeFormPost)
+ resp, err := sender.Do(req)
+ if err != nil {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errCodeSendingFails, err.Error())
+ }
+ defer resp.Body.Close()
+
+ rb, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errCodeHandlingFails, err.Error())
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errCodeHandlingFails, errStatusNotOK)
+ }
+
+ if len(strings.Trim(string(rb), " ")) == 0 {
+ return nil, ErrDeviceCodeEmpty
+ }
+
+ var code DeviceCode
+ err = json.Unmarshal(rb, &code)
+ if err != nil {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errCodeHandlingFails, err.Error())
+ }
+
+ code.ClientID = clientID
+ code.Resource = resource
+ code.OAuthConfig = oauthConfig
+
+ return &code, nil
+}
+
+// CheckForUserCompletion takes a DeviceCode and checks with the Azure AD OAuth endpoint
+// to see if the device flow has: been completed, timed out, or otherwise failed
+func CheckForUserCompletion(sender Sender, code *DeviceCode) (*Token, error) {
+ v := url.Values{
+ "client_id": []string{code.ClientID},
+ "code": []string{*code.DeviceCode},
+ "grant_type": []string{OAuthGrantTypeDeviceCode},
+ "resource": []string{code.Resource},
+ }
+
+ s := v.Encode()
+ body := ioutil.NopCloser(strings.NewReader(s))
+
+ req, err := http.NewRequest(http.MethodPost, code.OAuthConfig.TokenEndpoint.String(), body)
+ if err != nil {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errTokenSendingFails, err.Error())
+ }
+
+ req.ContentLength = int64(len(s))
+ req.Header.Set(contentType, mimeTypeFormPost)
+ resp, err := sender.Do(req)
+ if err != nil {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errTokenSendingFails, err.Error())
+ }
+ defer resp.Body.Close()
+
+ rb, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errTokenHandlingFails, err.Error())
+ }
+
+ if resp.StatusCode != http.StatusOK && len(strings.Trim(string(rb), " ")) == 0 {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errTokenHandlingFails, errStatusNotOK)
+ }
+ if len(strings.Trim(string(rb), " ")) == 0 {
+ return nil, ErrOAuthTokenEmpty
+ }
+
+ var token deviceToken
+ err = json.Unmarshal(rb, &token)
+ if err != nil {
+ return nil, fmt.Errorf("%s %s: %s", logPrefix, errTokenHandlingFails, err.Error())
+ }
+
+ if token.Error == nil {
+ return &token.Token, nil
+ }
+
+ switch *token.Error {
+ case "authorization_pending":
+ return nil, ErrDeviceAuthorizationPending
+ case "slow_down":
+ return nil, ErrDeviceSlowDown
+ case "access_denied":
+ return nil, ErrDeviceAccessDenied
+ case "code_expired":
+ return nil, ErrDeviceCodeExpired
+ default:
+ return nil, ErrDeviceGeneric
+ }
+}
+
+// WaitForUserCompletion calls CheckForUserCompletion repeatedly until a token is granted or an error state occurs.
+// This prevents the user from looping and checking against 'ErrDeviceAuthorizationPending'.
+func WaitForUserCompletion(sender Sender, code *DeviceCode) (*Token, error) {
+ intervalDuration := time.Duration(*code.Interval) * time.Second
+ waitDuration := intervalDuration
+
+ for {
+ token, err := CheckForUserCompletion(sender, code)
+
+ if err == nil {
+ return token, nil
+ }
+
+ switch err {
+ case ErrDeviceSlowDown:
+ waitDuration += waitDuration
+ case ErrDeviceAuthorizationPending:
+ // noop
+ default: // everything else is "fatal" to us
+ return nil, err
+ }
+
+ if waitDuration > (intervalDuration * 3) {
+ return nil, fmt.Errorf("%s Error waiting for user to complete device flow. Server told us to slow_down too much", logPrefix)
+ }
+
+ time.Sleep(waitDuration)
+ }
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go b/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go
new file mode 100644
index 0000000000..9e15f2751f
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go
@@ -0,0 +1,73 @@
+package adal
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+)
+
+// LoadToken restores a Token object from a file located at 'path'.
+func LoadToken(path string) (*Token, error) {
+ file, err := os.Open(path)
+ if err != nil {
+ return nil, fmt.Errorf("failed to open file (%s) while loading token: %v", path, err)
+ }
+ defer file.Close()
+
+ var token Token
+
+ dec := json.NewDecoder(file)
+ if err = dec.Decode(&token); err != nil {
+ return nil, fmt.Errorf("failed to decode contents of file (%s) into Token representation: %v", path, err)
+ }
+ return &token, nil
+}
+
+// SaveToken persists an oauth token at the given location on disk.
+// It moves the new file into place so it can safely be used to replace an existing file
+// that maybe accessed by multiple processes.
+func SaveToken(path string, mode os.FileMode, token Token) error {
+ dir := filepath.Dir(path)
+ err := os.MkdirAll(dir, os.ModePerm)
+ if err != nil {
+ return fmt.Errorf("failed to create directory (%s) to store token in: %v", dir, err)
+ }
+
+ newFile, err := ioutil.TempFile(dir, "token")
+ if err != nil {
+ return fmt.Errorf("failed to create the temp file to write the token: %v", err)
+ }
+ tempPath := newFile.Name()
+
+ if err := json.NewEncoder(newFile).Encode(token); err != nil {
+ return fmt.Errorf("failed to encode token to file (%s) while saving token: %v", tempPath, err)
+ }
+ if err := newFile.Close(); err != nil {
+ return fmt.Errorf("failed to close temp file %s: %v", tempPath, err)
+ }
+
+ // Atomic replace to avoid multi-writer file corruptions
+ if err := os.Rename(tempPath, path); err != nil {
+ return fmt.Errorf("failed to move temporary token to desired output location. src=%s dst=%s: %v", tempPath, path, err)
+ }
+ if err := os.Chmod(path, mode); err != nil {
+ return fmt.Errorf("failed to chmod the token file %s: %v", path, err)
+ }
+ return nil
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/sender.go b/vendor/github.com/Azure/go-autorest/autorest/adal/sender.go
new file mode 100644
index 0000000000..834401e00d
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/adal/sender.go
@@ -0,0 +1,60 @@
+package adal
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "net/http"
+)
+
+const (
+ contentType = "Content-Type"
+ mimeTypeFormPost = "application/x-www-form-urlencoded"
+)
+
+// Sender is the interface that wraps the Do method to send HTTP requests.
+//
+// The standard http.Client conforms to this interface.
+type Sender interface {
+ Do(*http.Request) (*http.Response, error)
+}
+
+// SenderFunc is a method that implements the Sender interface.
+type SenderFunc func(*http.Request) (*http.Response, error)
+
+// Do implements the Sender interface on SenderFunc.
+func (sf SenderFunc) Do(r *http.Request) (*http.Response, error) {
+ return sf(r)
+}
+
+// SendDecorator takes and possibly decorates, by wrapping, a Sender. Decorators may affect the
+// http.Request and pass it along or, first, pass the http.Request along then react to the
+// http.Response result.
+type SendDecorator func(Sender) Sender
+
+// CreateSender creates, decorates, and returns, as a Sender, the default http.Client.
+func CreateSender(decorators ...SendDecorator) Sender {
+ return DecorateSender(&http.Client{}, decorators...)
+}
+
+// DecorateSender accepts a Sender and a, possibly empty, set of SendDecorators, which is applies to
+// the Sender. Decorators are applied in the order received, but their affect upon the request
+// depends on whether they are a pre-decorator (change the http.Request and then pass it along) or a
+// post-decorator (pass the http.Request along and react to the results in http.Response).
+func DecorateSender(s Sender, decorators ...SendDecorator) Sender {
+ for _, decorate := range decorators {
+ s = decorate(s)
+ }
+ return s
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/token.go b/vendor/github.com/Azure/go-autorest/autorest/adal/token.go
new file mode 100644
index 0000000000..effa87ab2f
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/adal/token.go
@@ -0,0 +1,985 @@
+package adal
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "context"
+ "crypto/rand"
+ "crypto/rsa"
+ "crypto/sha1"
+ "crypto/x509"
+ "encoding/base64"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "math"
+ "net"
+ "net/http"
+ "net/url"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/Azure/go-autorest/autorest/date"
+ "github.com/Azure/go-autorest/tracing"
+ "github.com/dgrijalva/jwt-go"
+)
+
+const (
+ defaultRefresh = 5 * time.Minute
+
+ // OAuthGrantTypeDeviceCode is the "grant_type" identifier used in device flow
+ OAuthGrantTypeDeviceCode = "device_code"
+
+ // OAuthGrantTypeClientCredentials is the "grant_type" identifier used in credential flows
+ OAuthGrantTypeClientCredentials = "client_credentials"
+
+ // OAuthGrantTypeUserPass is the "grant_type" identifier used in username and password auth flows
+ OAuthGrantTypeUserPass = "password"
+
+ // OAuthGrantTypeRefreshToken is the "grant_type" identifier used in refresh token flows
+ OAuthGrantTypeRefreshToken = "refresh_token"
+
+ // OAuthGrantTypeAuthorizationCode is the "grant_type" identifier used in authorization code flows
+ OAuthGrantTypeAuthorizationCode = "authorization_code"
+
+ // metadataHeader is the header required by MSI extension
+ metadataHeader = "Metadata"
+
+ // msiEndpoint is the well known endpoint for getting MSI authentications tokens
+ msiEndpoint = "http://169.254.169.254/metadata/identity/oauth2/token"
+
+ // the default number of attempts to refresh an MSI authentication token
+ defaultMaxMSIRefreshAttempts = 5
+)
+
+// OAuthTokenProvider is an interface which should be implemented by an access token retriever
+type OAuthTokenProvider interface {
+ OAuthToken() string
+}
+
+// TokenRefreshError is an interface used by errors returned during token refresh.
+type TokenRefreshError interface {
+ error
+ Response() *http.Response
+}
+
+// Refresher is an interface for token refresh functionality
+type Refresher interface {
+ Refresh() error
+ RefreshExchange(resource string) error
+ EnsureFresh() error
+}
+
+// RefresherWithContext is an interface for token refresh functionality
+type RefresherWithContext interface {
+ RefreshWithContext(ctx context.Context) error
+ RefreshExchangeWithContext(ctx context.Context, resource string) error
+ EnsureFreshWithContext(ctx context.Context) error
+}
+
+// TokenRefreshCallback is the type representing callbacks that will be called after
+// a successful token refresh
+type TokenRefreshCallback func(Token) error
+
+// Token encapsulates the access token used to authorize Azure requests.
+// https://docs.microsoft.com/en-us/azure/active-directory/develop/v1-oauth2-client-creds-grant-flow#service-to-service-access-token-response
+type Token struct {
+ AccessToken string `json:"access_token"`
+ RefreshToken string `json:"refresh_token"`
+
+ ExpiresIn json.Number `json:"expires_in"`
+ ExpiresOn json.Number `json:"expires_on"`
+ NotBefore json.Number `json:"not_before"`
+
+ Resource string `json:"resource"`
+ Type string `json:"token_type"`
+}
+
+func newToken() Token {
+ return Token{
+ ExpiresIn: "0",
+ ExpiresOn: "0",
+ NotBefore: "0",
+ }
+}
+
+// IsZero returns true if the token object is zero-initialized.
+func (t Token) IsZero() bool {
+ return t == Token{}
+}
+
+// Expires returns the time.Time when the Token expires.
+func (t Token) Expires() time.Time {
+ s, err := t.ExpiresOn.Float64()
+ if err != nil {
+ s = -3600
+ }
+
+ expiration := date.NewUnixTimeFromSeconds(s)
+
+ return time.Time(expiration).UTC()
+}
+
+// IsExpired returns true if the Token is expired, false otherwise.
+func (t Token) IsExpired() bool {
+ return t.WillExpireIn(0)
+}
+
+// WillExpireIn returns true if the Token will expire after the passed time.Duration interval
+// from now, false otherwise.
+func (t Token) WillExpireIn(d time.Duration) bool {
+ return !t.Expires().After(time.Now().Add(d))
+}
+
+//OAuthToken return the current access token
+func (t *Token) OAuthToken() string {
+ return t.AccessToken
+}
+
+// ServicePrincipalSecret is an interface that allows various secret mechanism to fill the form
+// that is submitted when acquiring an oAuth token.
+type ServicePrincipalSecret interface {
+ SetAuthenticationValues(spt *ServicePrincipalToken, values *url.Values) error
+}
+
+// ServicePrincipalNoSecret represents a secret type that contains no secret
+// meaning it is not valid for fetching a fresh token. This is used by Manual
+type ServicePrincipalNoSecret struct {
+}
+
+// SetAuthenticationValues is a method of the interface ServicePrincipalSecret
+// It only returns an error for the ServicePrincipalNoSecret type
+func (noSecret *ServicePrincipalNoSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
+ return fmt.Errorf("Manually created ServicePrincipalToken does not contain secret material to retrieve a new access token")
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (noSecret ServicePrincipalNoSecret) MarshalJSON() ([]byte, error) {
+ type tokenType struct {
+ Type string `json:"type"`
+ }
+ return json.Marshal(tokenType{
+ Type: "ServicePrincipalNoSecret",
+ })
+}
+
+// ServicePrincipalTokenSecret implements ServicePrincipalSecret for client_secret type authorization.
+type ServicePrincipalTokenSecret struct {
+ ClientSecret string `json:"value"`
+}
+
+// SetAuthenticationValues is a method of the interface ServicePrincipalSecret.
+// It will populate the form submitted during oAuth Token Acquisition using the client_secret.
+func (tokenSecret *ServicePrincipalTokenSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
+ v.Set("client_secret", tokenSecret.ClientSecret)
+ return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (tokenSecret ServicePrincipalTokenSecret) MarshalJSON() ([]byte, error) {
+ type tokenType struct {
+ Type string `json:"type"`
+ Value string `json:"value"`
+ }
+ return json.Marshal(tokenType{
+ Type: "ServicePrincipalTokenSecret",
+ Value: tokenSecret.ClientSecret,
+ })
+}
+
+// ServicePrincipalCertificateSecret implements ServicePrincipalSecret for generic RSA cert auth with signed JWTs.
+type ServicePrincipalCertificateSecret struct {
+ Certificate *x509.Certificate
+ PrivateKey *rsa.PrivateKey
+}
+
+// SignJwt returns the JWT signed with the certificate's private key.
+func (secret *ServicePrincipalCertificateSecret) SignJwt(spt *ServicePrincipalToken) (string, error) {
+ hasher := sha1.New()
+ _, err := hasher.Write(secret.Certificate.Raw)
+ if err != nil {
+ return "", err
+ }
+
+ thumbprint := base64.URLEncoding.EncodeToString(hasher.Sum(nil))
+
+ // The jti (JWT ID) claim provides a unique identifier for the JWT.
+ jti := make([]byte, 20)
+ _, err = rand.Read(jti)
+ if err != nil {
+ return "", err
+ }
+
+ token := jwt.New(jwt.SigningMethodRS256)
+ token.Header["x5t"] = thumbprint
+ x5c := []string{base64.StdEncoding.EncodeToString(secret.Certificate.Raw)}
+ token.Header["x5c"] = x5c
+ token.Claims = jwt.MapClaims{
+ "aud": spt.inner.OauthConfig.TokenEndpoint.String(),
+ "iss": spt.inner.ClientID,
+ "sub": spt.inner.ClientID,
+ "jti": base64.URLEncoding.EncodeToString(jti),
+ "nbf": time.Now().Unix(),
+ "exp": time.Now().Add(time.Hour * 24).Unix(),
+ }
+
+ signedString, err := token.SignedString(secret.PrivateKey)
+ return signedString, err
+}
+
+// SetAuthenticationValues is a method of the interface ServicePrincipalSecret.
+// It will populate the form submitted during oAuth Token Acquisition using a JWT signed with a certificate.
+func (secret *ServicePrincipalCertificateSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
+ jwt, err := secret.SignJwt(spt)
+ if err != nil {
+ return err
+ }
+
+ v.Set("client_assertion", jwt)
+ v.Set("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer")
+ return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (secret ServicePrincipalCertificateSecret) MarshalJSON() ([]byte, error) {
+ return nil, errors.New("marshalling ServicePrincipalCertificateSecret is not supported")
+}
+
+// ServicePrincipalMSISecret implements ServicePrincipalSecret for machines running the MSI Extension.
+type ServicePrincipalMSISecret struct {
+}
+
+// SetAuthenticationValues is a method of the interface ServicePrincipalSecret.
+func (msiSecret *ServicePrincipalMSISecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
+ return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (msiSecret ServicePrincipalMSISecret) MarshalJSON() ([]byte, error) {
+ return nil, errors.New("marshalling ServicePrincipalMSISecret is not supported")
+}
+
+// ServicePrincipalUsernamePasswordSecret implements ServicePrincipalSecret for username and password auth.
+type ServicePrincipalUsernamePasswordSecret struct {
+ Username string `json:"username"`
+ Password string `json:"password"`
+}
+
+// SetAuthenticationValues is a method of the interface ServicePrincipalSecret.
+func (secret *ServicePrincipalUsernamePasswordSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
+ v.Set("username", secret.Username)
+ v.Set("password", secret.Password)
+ return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (secret ServicePrincipalUsernamePasswordSecret) MarshalJSON() ([]byte, error) {
+ type tokenType struct {
+ Type string `json:"type"`
+ Username string `json:"username"`
+ Password string `json:"password"`
+ }
+ return json.Marshal(tokenType{
+ Type: "ServicePrincipalUsernamePasswordSecret",
+ Username: secret.Username,
+ Password: secret.Password,
+ })
+}
+
+// ServicePrincipalAuthorizationCodeSecret implements ServicePrincipalSecret for authorization code auth.
+type ServicePrincipalAuthorizationCodeSecret struct {
+ ClientSecret string `json:"value"`
+ AuthorizationCode string `json:"authCode"`
+ RedirectURI string `json:"redirect"`
+}
+
+// SetAuthenticationValues is a method of the interface ServicePrincipalSecret.
+func (secret *ServicePrincipalAuthorizationCodeSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
+ v.Set("code", secret.AuthorizationCode)
+ v.Set("client_secret", secret.ClientSecret)
+ v.Set("redirect_uri", secret.RedirectURI)
+ return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (secret ServicePrincipalAuthorizationCodeSecret) MarshalJSON() ([]byte, error) {
+ type tokenType struct {
+ Type string `json:"type"`
+ Value string `json:"value"`
+ AuthCode string `json:"authCode"`
+ Redirect string `json:"redirect"`
+ }
+ return json.Marshal(tokenType{
+ Type: "ServicePrincipalAuthorizationCodeSecret",
+ Value: secret.ClientSecret,
+ AuthCode: secret.AuthorizationCode,
+ Redirect: secret.RedirectURI,
+ })
+}
+
+// ServicePrincipalToken encapsulates a Token created for a Service Principal.
+type ServicePrincipalToken struct {
+ inner servicePrincipalToken
+ refreshLock *sync.RWMutex
+ sender Sender
+ refreshCallbacks []TokenRefreshCallback
+ // MaxMSIRefreshAttempts is the maximum number of attempts to refresh an MSI token.
+ MaxMSIRefreshAttempts int
+}
+
+// MarshalTokenJSON returns the marshalled inner token.
+func (spt ServicePrincipalToken) MarshalTokenJSON() ([]byte, error) {
+ return json.Marshal(spt.inner.Token)
+}
+
+// SetRefreshCallbacks replaces any existing refresh callbacks with the specified callbacks.
+func (spt *ServicePrincipalToken) SetRefreshCallbacks(callbacks []TokenRefreshCallback) {
+ spt.refreshCallbacks = callbacks
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (spt ServicePrincipalToken) MarshalJSON() ([]byte, error) {
+ return json.Marshal(spt.inner)
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface.
+func (spt *ServicePrincipalToken) UnmarshalJSON(data []byte) error {
+ // need to determine the token type
+ raw := map[string]interface{}{}
+ err := json.Unmarshal(data, &raw)
+ if err != nil {
+ return err
+ }
+ secret := raw["secret"].(map[string]interface{})
+ switch secret["type"] {
+ case "ServicePrincipalNoSecret":
+ spt.inner.Secret = &ServicePrincipalNoSecret{}
+ case "ServicePrincipalTokenSecret":
+ spt.inner.Secret = &ServicePrincipalTokenSecret{}
+ case "ServicePrincipalCertificateSecret":
+ return errors.New("unmarshalling ServicePrincipalCertificateSecret is not supported")
+ case "ServicePrincipalMSISecret":
+ return errors.New("unmarshalling ServicePrincipalMSISecret is not supported")
+ case "ServicePrincipalUsernamePasswordSecret":
+ spt.inner.Secret = &ServicePrincipalUsernamePasswordSecret{}
+ case "ServicePrincipalAuthorizationCodeSecret":
+ spt.inner.Secret = &ServicePrincipalAuthorizationCodeSecret{}
+ default:
+ return fmt.Errorf("unrecognized token type '%s'", secret["type"])
+ }
+ err = json.Unmarshal(data, &spt.inner)
+ if err != nil {
+ return err
+ }
+ // Don't override the refreshLock or the sender if those have been already set.
+ if spt.refreshLock == nil {
+ spt.refreshLock = &sync.RWMutex{}
+ }
+ if spt.sender == nil {
+ spt.sender = &http.Client{Transport: tracing.Transport}
+ }
+ return nil
+}
+
+// internal type used for marshalling/unmarshalling
+type servicePrincipalToken struct {
+ Token Token `json:"token"`
+ Secret ServicePrincipalSecret `json:"secret"`
+ OauthConfig OAuthConfig `json:"oauth"`
+ ClientID string `json:"clientID"`
+ Resource string `json:"resource"`
+ AutoRefresh bool `json:"autoRefresh"`
+ RefreshWithin time.Duration `json:"refreshWithin"`
+}
+
+func validateOAuthConfig(oac OAuthConfig) error {
+ if oac.IsZero() {
+ return fmt.Errorf("parameter 'oauthConfig' cannot be zero-initialized")
+ }
+ return nil
+}
+
+// NewServicePrincipalTokenWithSecret create a ServicePrincipalToken using the supplied ServicePrincipalSecret implementation.
+func NewServicePrincipalTokenWithSecret(oauthConfig OAuthConfig, id string, resource string, secret ServicePrincipalSecret, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+ if err := validateOAuthConfig(oauthConfig); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(id, "id"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(resource, "resource"); err != nil {
+ return nil, err
+ }
+ if secret == nil {
+ return nil, fmt.Errorf("parameter 'secret' cannot be nil")
+ }
+ spt := &ServicePrincipalToken{
+ inner: servicePrincipalToken{
+ Token: newToken(),
+ OauthConfig: oauthConfig,
+ Secret: secret,
+ ClientID: id,
+ Resource: resource,
+ AutoRefresh: true,
+ RefreshWithin: defaultRefresh,
+ },
+ refreshLock: &sync.RWMutex{},
+ sender: &http.Client{Transport: tracing.Transport},
+ refreshCallbacks: callbacks,
+ }
+ return spt, nil
+}
+
+// NewServicePrincipalTokenFromManualToken creates a ServicePrincipalToken using the supplied token
+func NewServicePrincipalTokenFromManualToken(oauthConfig OAuthConfig, clientID string, resource string, token Token, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+ if err := validateOAuthConfig(oauthConfig); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(clientID, "clientID"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(resource, "resource"); err != nil {
+ return nil, err
+ }
+ if token.IsZero() {
+ return nil, fmt.Errorf("parameter 'token' cannot be zero-initialized")
+ }
+ spt, err := NewServicePrincipalTokenWithSecret(
+ oauthConfig,
+ clientID,
+ resource,
+ &ServicePrincipalNoSecret{},
+ callbacks...)
+ if err != nil {
+ return nil, err
+ }
+
+ spt.inner.Token = token
+
+ return spt, nil
+}
+
+// NewServicePrincipalTokenFromManualTokenSecret creates a ServicePrincipalToken using the supplied token and secret
+func NewServicePrincipalTokenFromManualTokenSecret(oauthConfig OAuthConfig, clientID string, resource string, token Token, secret ServicePrincipalSecret, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+ if err := validateOAuthConfig(oauthConfig); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(clientID, "clientID"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(resource, "resource"); err != nil {
+ return nil, err
+ }
+ if secret == nil {
+ return nil, fmt.Errorf("parameter 'secret' cannot be nil")
+ }
+ if token.IsZero() {
+ return nil, fmt.Errorf("parameter 'token' cannot be zero-initialized")
+ }
+ spt, err := NewServicePrincipalTokenWithSecret(
+ oauthConfig,
+ clientID,
+ resource,
+ secret,
+ callbacks...)
+ if err != nil {
+ return nil, err
+ }
+
+ spt.inner.Token = token
+
+ return spt, nil
+}
+
+// NewServicePrincipalToken creates a ServicePrincipalToken from the supplied Service Principal
+// credentials scoped to the named resource.
+func NewServicePrincipalToken(oauthConfig OAuthConfig, clientID string, secret string, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+ if err := validateOAuthConfig(oauthConfig); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(clientID, "clientID"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(secret, "secret"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(resource, "resource"); err != nil {
+ return nil, err
+ }
+ return NewServicePrincipalTokenWithSecret(
+ oauthConfig,
+ clientID,
+ resource,
+ &ServicePrincipalTokenSecret{
+ ClientSecret: secret,
+ },
+ callbacks...,
+ )
+}
+
+// NewServicePrincipalTokenFromCertificate creates a ServicePrincipalToken from the supplied pkcs12 bytes.
+func NewServicePrincipalTokenFromCertificate(oauthConfig OAuthConfig, clientID string, certificate *x509.Certificate, privateKey *rsa.PrivateKey, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+ if err := validateOAuthConfig(oauthConfig); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(clientID, "clientID"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(resource, "resource"); err != nil {
+ return nil, err
+ }
+ if certificate == nil {
+ return nil, fmt.Errorf("parameter 'certificate' cannot be nil")
+ }
+ if privateKey == nil {
+ return nil, fmt.Errorf("parameter 'privateKey' cannot be nil")
+ }
+ return NewServicePrincipalTokenWithSecret(
+ oauthConfig,
+ clientID,
+ resource,
+ &ServicePrincipalCertificateSecret{
+ PrivateKey: privateKey,
+ Certificate: certificate,
+ },
+ callbacks...,
+ )
+}
+
+// NewServicePrincipalTokenFromUsernamePassword creates a ServicePrincipalToken from the username and password.
+func NewServicePrincipalTokenFromUsernamePassword(oauthConfig OAuthConfig, clientID string, username string, password string, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+ if err := validateOAuthConfig(oauthConfig); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(clientID, "clientID"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(username, "username"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(password, "password"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(resource, "resource"); err != nil {
+ return nil, err
+ }
+ return NewServicePrincipalTokenWithSecret(
+ oauthConfig,
+ clientID,
+ resource,
+ &ServicePrincipalUsernamePasswordSecret{
+ Username: username,
+ Password: password,
+ },
+ callbacks...,
+ )
+}
+
+// NewServicePrincipalTokenFromAuthorizationCode creates a ServicePrincipalToken from the
+func NewServicePrincipalTokenFromAuthorizationCode(oauthConfig OAuthConfig, clientID string, clientSecret string, authorizationCode string, redirectURI string, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+
+ if err := validateOAuthConfig(oauthConfig); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(clientID, "clientID"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(clientSecret, "clientSecret"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(authorizationCode, "authorizationCode"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(redirectURI, "redirectURI"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(resource, "resource"); err != nil {
+ return nil, err
+ }
+
+ return NewServicePrincipalTokenWithSecret(
+ oauthConfig,
+ clientID,
+ resource,
+ &ServicePrincipalAuthorizationCodeSecret{
+ ClientSecret: clientSecret,
+ AuthorizationCode: authorizationCode,
+ RedirectURI: redirectURI,
+ },
+ callbacks...,
+ )
+}
+
+// GetMSIVMEndpoint gets the MSI endpoint on Virtual Machines.
+func GetMSIVMEndpoint() (string, error) {
+ return msiEndpoint, nil
+}
+
+// NewServicePrincipalTokenFromMSI creates a ServicePrincipalToken via the MSI VM Extension.
+// It will use the system assigned identity when creating the token.
+func NewServicePrincipalTokenFromMSI(msiEndpoint, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+ return newServicePrincipalTokenFromMSI(msiEndpoint, resource, nil, callbacks...)
+}
+
+// NewServicePrincipalTokenFromMSIWithUserAssignedID creates a ServicePrincipalToken via the MSI VM Extension.
+// It will use the specified user assigned identity when creating the token.
+func NewServicePrincipalTokenFromMSIWithUserAssignedID(msiEndpoint, resource string, userAssignedID string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+ return newServicePrincipalTokenFromMSI(msiEndpoint, resource, &userAssignedID, callbacks...)
+}
+
+func newServicePrincipalTokenFromMSI(msiEndpoint, resource string, userAssignedID *string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
+ if err := validateStringParam(msiEndpoint, "msiEndpoint"); err != nil {
+ return nil, err
+ }
+ if err := validateStringParam(resource, "resource"); err != nil {
+ return nil, err
+ }
+ if userAssignedID != nil {
+ if err := validateStringParam(*userAssignedID, "userAssignedID"); err != nil {
+ return nil, err
+ }
+ }
+ // We set the oauth config token endpoint to be MSI's endpoint
+ msiEndpointURL, err := url.Parse(msiEndpoint)
+ if err != nil {
+ return nil, err
+ }
+
+ v := url.Values{}
+ v.Set("resource", resource)
+ v.Set("api-version", "2018-02-01")
+ if userAssignedID != nil {
+ v.Set("client_id", *userAssignedID)
+ }
+ msiEndpointURL.RawQuery = v.Encode()
+
+ spt := &ServicePrincipalToken{
+ inner: servicePrincipalToken{
+ Token: newToken(),
+ OauthConfig: OAuthConfig{
+ TokenEndpoint: *msiEndpointURL,
+ },
+ Secret: &ServicePrincipalMSISecret{},
+ Resource: resource,
+ AutoRefresh: true,
+ RefreshWithin: defaultRefresh,
+ },
+ refreshLock: &sync.RWMutex{},
+ sender: &http.Client{Transport: tracing.Transport},
+ refreshCallbacks: callbacks,
+ MaxMSIRefreshAttempts: defaultMaxMSIRefreshAttempts,
+ }
+
+ if userAssignedID != nil {
+ spt.inner.ClientID = *userAssignedID
+ }
+
+ return spt, nil
+}
+
+// internal type that implements TokenRefreshError
+type tokenRefreshError struct {
+ message string
+ resp *http.Response
+}
+
+// Error implements the error interface which is part of the TokenRefreshError interface.
+func (tre tokenRefreshError) Error() string {
+ return tre.message
+}
+
+// Response implements the TokenRefreshError interface, it returns the raw HTTP response from the refresh operation.
+func (tre tokenRefreshError) Response() *http.Response {
+ return tre.resp
+}
+
+func newTokenRefreshError(message string, resp *http.Response) TokenRefreshError {
+ return tokenRefreshError{message: message, resp: resp}
+}
+
+// EnsureFresh will refresh the token if it will expire within the refresh window (as set by
+// RefreshWithin) and autoRefresh flag is on. This method is safe for concurrent use.
+func (spt *ServicePrincipalToken) EnsureFresh() error {
+ return spt.EnsureFreshWithContext(context.Background())
+}
+
+// EnsureFreshWithContext will refresh the token if it will expire within the refresh window (as set by
+// RefreshWithin) and autoRefresh flag is on. This method is safe for concurrent use.
+func (spt *ServicePrincipalToken) EnsureFreshWithContext(ctx context.Context) error {
+ if spt.inner.AutoRefresh && spt.inner.Token.WillExpireIn(spt.inner.RefreshWithin) {
+ // take the write lock then check to see if the token was already refreshed
+ spt.refreshLock.Lock()
+ defer spt.refreshLock.Unlock()
+ if spt.inner.Token.WillExpireIn(spt.inner.RefreshWithin) {
+ return spt.refreshInternal(ctx, spt.inner.Resource)
+ }
+ }
+ return nil
+}
+
+// InvokeRefreshCallbacks calls any TokenRefreshCallbacks that were added to the SPT during initialization
+func (spt *ServicePrincipalToken) InvokeRefreshCallbacks(token Token) error {
+ if spt.refreshCallbacks != nil {
+ for _, callback := range spt.refreshCallbacks {
+ err := callback(spt.inner.Token)
+ if err != nil {
+ return fmt.Errorf("adal: TokenRefreshCallback handler failed. Error = '%v'", err)
+ }
+ }
+ }
+ return nil
+}
+
+// Refresh obtains a fresh token for the Service Principal.
+// This method is not safe for concurrent use and should be syncrhonized.
+func (spt *ServicePrincipalToken) Refresh() error {
+ return spt.RefreshWithContext(context.Background())
+}
+
+// RefreshWithContext obtains a fresh token for the Service Principal.
+// This method is not safe for concurrent use and should be syncrhonized.
+func (spt *ServicePrincipalToken) RefreshWithContext(ctx context.Context) error {
+ spt.refreshLock.Lock()
+ defer spt.refreshLock.Unlock()
+ return spt.refreshInternal(ctx, spt.inner.Resource)
+}
+
+// RefreshExchange refreshes the token, but for a different resource.
+// This method is not safe for concurrent use and should be syncrhonized.
+func (spt *ServicePrincipalToken) RefreshExchange(resource string) error {
+ return spt.RefreshExchangeWithContext(context.Background(), resource)
+}
+
+// RefreshExchangeWithContext refreshes the token, but for a different resource.
+// This method is not safe for concurrent use and should be syncrhonized.
+func (spt *ServicePrincipalToken) RefreshExchangeWithContext(ctx context.Context, resource string) error {
+ spt.refreshLock.Lock()
+ defer spt.refreshLock.Unlock()
+ return spt.refreshInternal(ctx, resource)
+}
+
+func (spt *ServicePrincipalToken) getGrantType() string {
+ switch spt.inner.Secret.(type) {
+ case *ServicePrincipalUsernamePasswordSecret:
+ return OAuthGrantTypeUserPass
+ case *ServicePrincipalAuthorizationCodeSecret:
+ return OAuthGrantTypeAuthorizationCode
+ default:
+ return OAuthGrantTypeClientCredentials
+ }
+}
+
+func isIMDS(u url.URL) bool {
+ imds, err := url.Parse(msiEndpoint)
+ if err != nil {
+ return false
+ }
+ return u.Host == imds.Host && u.Path == imds.Path
+}
+
+func (spt *ServicePrincipalToken) refreshInternal(ctx context.Context, resource string) error {
+ req, err := http.NewRequest(http.MethodPost, spt.inner.OauthConfig.TokenEndpoint.String(), nil)
+ if err != nil {
+ return fmt.Errorf("adal: Failed to build the refresh request. Error = '%v'", err)
+ }
+ req.Header.Add("User-Agent", UserAgent())
+ req = req.WithContext(ctx)
+ if !isIMDS(spt.inner.OauthConfig.TokenEndpoint) {
+ v := url.Values{}
+ v.Set("client_id", spt.inner.ClientID)
+ v.Set("resource", resource)
+
+ if spt.inner.Token.RefreshToken != "" {
+ v.Set("grant_type", OAuthGrantTypeRefreshToken)
+ v.Set("refresh_token", spt.inner.Token.RefreshToken)
+ // web apps must specify client_secret when refreshing tokens
+ // see https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-protocols-oauth-code#refreshing-the-access-tokens
+ if spt.getGrantType() == OAuthGrantTypeAuthorizationCode {
+ err := spt.inner.Secret.SetAuthenticationValues(spt, &v)
+ if err != nil {
+ return err
+ }
+ }
+ } else {
+ v.Set("grant_type", spt.getGrantType())
+ err := spt.inner.Secret.SetAuthenticationValues(spt, &v)
+ if err != nil {
+ return err
+ }
+ }
+
+ s := v.Encode()
+ body := ioutil.NopCloser(strings.NewReader(s))
+ req.ContentLength = int64(len(s))
+ req.Header.Set(contentType, mimeTypeFormPost)
+ req.Body = body
+ }
+
+ if _, ok := spt.inner.Secret.(*ServicePrincipalMSISecret); ok {
+ req.Method = http.MethodGet
+ req.Header.Set(metadataHeader, "true")
+ }
+
+ var resp *http.Response
+ if isIMDS(spt.inner.OauthConfig.TokenEndpoint) {
+ resp, err = retryForIMDS(spt.sender, req, spt.MaxMSIRefreshAttempts)
+ } else {
+ resp, err = spt.sender.Do(req)
+ }
+ if err != nil {
+ return newTokenRefreshError(fmt.Sprintf("adal: Failed to execute the refresh request. Error = '%v'", err), nil)
+ }
+
+ defer resp.Body.Close()
+ rb, err := ioutil.ReadAll(resp.Body)
+
+ if resp.StatusCode != http.StatusOK {
+ if err != nil {
+ return newTokenRefreshError(fmt.Sprintf("adal: Refresh request failed. Status Code = '%d'. Failed reading response body: %v", resp.StatusCode, err), resp)
+ }
+ return newTokenRefreshError(fmt.Sprintf("adal: Refresh request failed. Status Code = '%d'. Response body: %s", resp.StatusCode, string(rb)), resp)
+ }
+
+ // for the following error cases don't return a TokenRefreshError. the operation succeeded
+ // but some transient failure happened during deserialization. by returning a generic error
+ // the retry logic will kick in (we don't retry on TokenRefreshError).
+
+ if err != nil {
+ return fmt.Errorf("adal: Failed to read a new service principal token during refresh. Error = '%v'", err)
+ }
+ if len(strings.Trim(string(rb), " ")) == 0 {
+ return fmt.Errorf("adal: Empty service principal token received during refresh")
+ }
+ var token Token
+ err = json.Unmarshal(rb, &token)
+ if err != nil {
+ return fmt.Errorf("adal: Failed to unmarshal the service principal token during refresh. Error = '%v' JSON = '%s'", err, string(rb))
+ }
+
+ spt.inner.Token = token
+
+ return spt.InvokeRefreshCallbacks(token)
+}
+
+// retry logic specific to retrieving a token from the IMDS endpoint
+func retryForIMDS(sender Sender, req *http.Request, maxAttempts int) (resp *http.Response, err error) {
+ // copied from client.go due to circular dependency
+ retries := []int{
+ http.StatusRequestTimeout, // 408
+ http.StatusTooManyRequests, // 429
+ http.StatusInternalServerError, // 500
+ http.StatusBadGateway, // 502
+ http.StatusServiceUnavailable, // 503
+ http.StatusGatewayTimeout, // 504
+ }
+ // extra retry status codes specific to IMDS
+ retries = append(retries,
+ http.StatusNotFound,
+ http.StatusGone,
+ // all remaining 5xx
+ http.StatusNotImplemented,
+ http.StatusHTTPVersionNotSupported,
+ http.StatusVariantAlsoNegotiates,
+ http.StatusInsufficientStorage,
+ http.StatusLoopDetected,
+ http.StatusNotExtended,
+ http.StatusNetworkAuthenticationRequired)
+
+ // see https://docs.microsoft.com/en-us/azure/active-directory/managed-service-identity/how-to-use-vm-token#retry-guidance
+
+ const maxDelay time.Duration = 60 * time.Second
+
+ attempt := 0
+ delay := time.Duration(0)
+
+ for attempt < maxAttempts {
+ resp, err = sender.Do(req)
+ // retry on temporary network errors, e.g. transient network failures.
+ // if we don't receive a response then assume we can't connect to the
+ // endpoint so we're likely not running on an Azure VM so don't retry.
+ if (err != nil && !isTemporaryNetworkError(err)) || resp == nil || resp.StatusCode == http.StatusOK || !containsInt(retries, resp.StatusCode) {
+ return
+ }
+
+ // perform exponential backoff with a cap.
+ // must increment attempt before calculating delay.
+ attempt++
+ // the base value of 2 is the "delta backoff" as specified in the guidance doc
+ delay += (time.Duration(math.Pow(2, float64(attempt))) * time.Second)
+ if delay > maxDelay {
+ delay = maxDelay
+ }
+
+ select {
+ case <-time.After(delay):
+ // intentionally left blank
+ case <-req.Context().Done():
+ err = req.Context().Err()
+ return
+ }
+ }
+ return
+}
+
+// returns true if the specified error is a temporary network error or false if it's not.
+// if the error doesn't implement the net.Error interface the return value is true.
+func isTemporaryNetworkError(err error) bool {
+ if netErr, ok := err.(net.Error); !ok || (ok && netErr.Temporary()) {
+ return true
+ }
+ return false
+}
+
+// returns true if slice ints contains the value n
+func containsInt(ints []int, n int) bool {
+ for _, i := range ints {
+ if i == n {
+ return true
+ }
+ }
+ return false
+}
+
+// SetAutoRefresh enables or disables automatic refreshing of stale tokens.
+func (spt *ServicePrincipalToken) SetAutoRefresh(autoRefresh bool) {
+ spt.inner.AutoRefresh = autoRefresh
+}
+
+// SetRefreshWithin sets the interval within which if the token will expire, EnsureFresh will
+// refresh the token.
+func (spt *ServicePrincipalToken) SetRefreshWithin(d time.Duration) {
+ spt.inner.RefreshWithin = d
+ return
+}
+
+// SetSender sets the http.Client used when obtaining the Service Principal token. An
+// undecorated http.Client is used by default.
+func (spt *ServicePrincipalToken) SetSender(s Sender) { spt.sender = s }
+
+// OAuthToken implements the OAuthTokenProvider interface. It returns the current access token.
+func (spt *ServicePrincipalToken) OAuthToken() string {
+ spt.refreshLock.RLock()
+ defer spt.refreshLock.RUnlock()
+ return spt.inner.Token.OAuthToken()
+}
+
+// Token returns a copy of the current token.
+func (spt *ServicePrincipalToken) Token() Token {
+ spt.refreshLock.RLock()
+ defer spt.refreshLock.RUnlock()
+ return spt.inner.Token
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/version.go b/vendor/github.com/Azure/go-autorest/autorest/adal/version.go
new file mode 100644
index 0000000000..c867b34843
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/adal/version.go
@@ -0,0 +1,45 @@
+package adal
+
+import (
+ "fmt"
+ "runtime"
+)
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+const number = "v1.0.0"
+
+var (
+ ua = fmt.Sprintf("Go/%s (%s-%s) go-autorest/adal/%s",
+ runtime.Version(),
+ runtime.GOARCH,
+ runtime.GOOS,
+ number,
+ )
+)
+
+// UserAgent returns a string containing the Go version, system architecture and OS, and the adal version.
+func UserAgent() string {
+ return ua
+}
+
+// AddToUserAgent adds an extension to the current user agent
+func AddToUserAgent(extension string) error {
+ if extension != "" {
+ ua = fmt.Sprintf("%s %s", ua, extension)
+ return nil
+ }
+ return fmt.Errorf("Extension was empty, User Agent remained as '%s'", ua)
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/authorization.go b/vendor/github.com/Azure/go-autorest/autorest/authorization.go
new file mode 100644
index 0000000000..bc474b406a
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/authorization.go
@@ -0,0 +1,260 @@
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+
+ "github.com/Azure/go-autorest/autorest/adal"
+ "github.com/Azure/go-autorest/tracing"
+)
+
+const (
+ bearerChallengeHeader = "Www-Authenticate"
+ bearer = "Bearer"
+ tenantID = "tenantID"
+ apiKeyAuthorizerHeader = "Ocp-Apim-Subscription-Key"
+ bingAPISdkHeader = "X-BingApis-SDK-Client"
+ golangBingAPISdkHeaderValue = "Go-SDK"
+)
+
+// Authorizer is the interface that provides a PrepareDecorator used to supply request
+// authorization. Most often, the Authorizer decorator runs last so it has access to the full
+// state of the formed HTTP request.
+type Authorizer interface {
+ WithAuthorization() PrepareDecorator
+}
+
+// NullAuthorizer implements a default, "do nothing" Authorizer.
+type NullAuthorizer struct{}
+
+// WithAuthorization returns a PrepareDecorator that does nothing.
+func (na NullAuthorizer) WithAuthorization() PrepareDecorator {
+ return WithNothing()
+}
+
+// APIKeyAuthorizer implements API Key authorization.
+type APIKeyAuthorizer struct {
+ headers map[string]interface{}
+ queryParameters map[string]interface{}
+}
+
+// NewAPIKeyAuthorizerWithHeaders creates an ApiKeyAuthorizer with headers.
+func NewAPIKeyAuthorizerWithHeaders(headers map[string]interface{}) *APIKeyAuthorizer {
+ return NewAPIKeyAuthorizer(headers, nil)
+}
+
+// NewAPIKeyAuthorizerWithQueryParameters creates an ApiKeyAuthorizer with query parameters.
+func NewAPIKeyAuthorizerWithQueryParameters(queryParameters map[string]interface{}) *APIKeyAuthorizer {
+ return NewAPIKeyAuthorizer(nil, queryParameters)
+}
+
+// NewAPIKeyAuthorizer creates an ApiKeyAuthorizer with headers.
+func NewAPIKeyAuthorizer(headers map[string]interface{}, queryParameters map[string]interface{}) *APIKeyAuthorizer {
+ return &APIKeyAuthorizer{headers: headers, queryParameters: queryParameters}
+}
+
+// WithAuthorization returns a PrepareDecorator that adds an HTTP headers and Query Parameters.
+func (aka *APIKeyAuthorizer) WithAuthorization() PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return DecoratePreparer(p, WithHeaders(aka.headers), WithQueryParameters(aka.queryParameters))
+ }
+}
+
+// CognitiveServicesAuthorizer implements authorization for Cognitive Services.
+type CognitiveServicesAuthorizer struct {
+ subscriptionKey string
+}
+
+// NewCognitiveServicesAuthorizer is
+func NewCognitiveServicesAuthorizer(subscriptionKey string) *CognitiveServicesAuthorizer {
+ return &CognitiveServicesAuthorizer{subscriptionKey: subscriptionKey}
+}
+
+// WithAuthorization is
+func (csa *CognitiveServicesAuthorizer) WithAuthorization() PrepareDecorator {
+ headers := make(map[string]interface{})
+ headers[apiKeyAuthorizerHeader] = csa.subscriptionKey
+ headers[bingAPISdkHeader] = golangBingAPISdkHeaderValue
+
+ return NewAPIKeyAuthorizerWithHeaders(headers).WithAuthorization()
+}
+
+// BearerAuthorizer implements the bearer authorization
+type BearerAuthorizer struct {
+ tokenProvider adal.OAuthTokenProvider
+}
+
+// NewBearerAuthorizer crates a BearerAuthorizer using the given token provider
+func NewBearerAuthorizer(tp adal.OAuthTokenProvider) *BearerAuthorizer {
+ return &BearerAuthorizer{tokenProvider: tp}
+}
+
+// WithAuthorization returns a PrepareDecorator that adds an HTTP Authorization header whose
+// value is "Bearer " followed by the token.
+//
+// By default, the token will be automatically refreshed through the Refresher interface.
+func (ba *BearerAuthorizer) WithAuthorization() PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ // the ordering is important here, prefer RefresherWithContext if available
+ if refresher, ok := ba.tokenProvider.(adal.RefresherWithContext); ok {
+ err = refresher.EnsureFreshWithContext(r.Context())
+ } else if refresher, ok := ba.tokenProvider.(adal.Refresher); ok {
+ err = refresher.EnsureFresh()
+ }
+ if err != nil {
+ var resp *http.Response
+ if tokError, ok := err.(adal.TokenRefreshError); ok {
+ resp = tokError.Response()
+ }
+ return r, NewErrorWithError(err, "azure.BearerAuthorizer", "WithAuthorization", resp,
+ "Failed to refresh the Token for request to %s", r.URL)
+ }
+ return Prepare(r, WithHeader(headerAuthorization, fmt.Sprintf("Bearer %s", ba.tokenProvider.OAuthToken())))
+ }
+ return r, err
+ })
+ }
+}
+
+// BearerAuthorizerCallbackFunc is the authentication callback signature.
+type BearerAuthorizerCallbackFunc func(tenantID, resource string) (*BearerAuthorizer, error)
+
+// BearerAuthorizerCallback implements bearer authorization via a callback.
+type BearerAuthorizerCallback struct {
+ sender Sender
+ callback BearerAuthorizerCallbackFunc
+}
+
+// NewBearerAuthorizerCallback creates a bearer authorization callback. The callback
+// is invoked when the HTTP request is submitted.
+func NewBearerAuthorizerCallback(sender Sender, callback BearerAuthorizerCallbackFunc) *BearerAuthorizerCallback {
+ if sender == nil {
+ sender = &http.Client{Transport: tracing.Transport}
+ }
+ return &BearerAuthorizerCallback{sender: sender, callback: callback}
+}
+
+// WithAuthorization returns a PrepareDecorator that adds an HTTP Authorization header whose value
+// is "Bearer " followed by the token. The BearerAuthorizer is obtained via a user-supplied callback.
+//
+// By default, the token will be automatically refreshed through the Refresher interface.
+func (bacb *BearerAuthorizerCallback) WithAuthorization() PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ // make a copy of the request and remove the body as it's not
+ // required and avoids us having to create a copy of it.
+ rCopy := *r
+ removeRequestBody(&rCopy)
+
+ resp, err := bacb.sender.Do(&rCopy)
+ if err == nil && resp.StatusCode == 401 {
+ defer resp.Body.Close()
+ if hasBearerChallenge(resp) {
+ bc, err := newBearerChallenge(resp)
+ if err != nil {
+ return r, err
+ }
+ if bacb.callback != nil {
+ ba, err := bacb.callback(bc.values[tenantID], bc.values["resource"])
+ if err != nil {
+ return r, err
+ }
+ return Prepare(r, ba.WithAuthorization())
+ }
+ }
+ }
+ }
+ return r, err
+ })
+ }
+}
+
+// returns true if the HTTP response contains a bearer challenge
+func hasBearerChallenge(resp *http.Response) bool {
+ authHeader := resp.Header.Get(bearerChallengeHeader)
+ if len(authHeader) == 0 || strings.Index(authHeader, bearer) < 0 {
+ return false
+ }
+ return true
+}
+
+type bearerChallenge struct {
+ values map[string]string
+}
+
+func newBearerChallenge(resp *http.Response) (bc bearerChallenge, err error) {
+ challenge := strings.TrimSpace(resp.Header.Get(bearerChallengeHeader))
+ trimmedChallenge := challenge[len(bearer)+1:]
+
+ // challenge is a set of key=value pairs that are comma delimited
+ pairs := strings.Split(trimmedChallenge, ",")
+ if len(pairs) < 1 {
+ err = fmt.Errorf("challenge '%s' contains no pairs", challenge)
+ return bc, err
+ }
+
+ bc.values = make(map[string]string)
+ for i := range pairs {
+ trimmedPair := strings.TrimSpace(pairs[i])
+ pair := strings.Split(trimmedPair, "=")
+ if len(pair) == 2 {
+ // remove the enclosing quotes
+ key := strings.Trim(pair[0], "\"")
+ value := strings.Trim(pair[1], "\"")
+
+ switch key {
+ case "authorization", "authorization_uri":
+ // strip the tenant ID from the authorization URL
+ asURL, err := url.Parse(value)
+ if err != nil {
+ return bc, err
+ }
+ bc.values[tenantID] = asURL.Path[1:]
+ default:
+ bc.values[key] = value
+ }
+ }
+ }
+
+ return bc, err
+}
+
+// EventGridKeyAuthorizer implements authorization for event grid using key authentication.
+type EventGridKeyAuthorizer struct {
+ topicKey string
+}
+
+// NewEventGridKeyAuthorizer creates a new EventGridKeyAuthorizer
+// with the specified topic key.
+func NewEventGridKeyAuthorizer(topicKey string) EventGridKeyAuthorizer {
+ return EventGridKeyAuthorizer{topicKey: topicKey}
+}
+
+// WithAuthorization returns a PrepareDecorator that adds the aeg-sas-key authentication header.
+func (egta EventGridKeyAuthorizer) WithAuthorization() PrepareDecorator {
+ headers := map[string]interface{}{
+ "aeg-sas-key": egta.topicKey,
+ }
+ return NewAPIKeyAuthorizerWithHeaders(headers).WithAuthorization()
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/autorest.go b/vendor/github.com/Azure/go-autorest/autorest/autorest.go
new file mode 100644
index 0000000000..aafdf021fd
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/autorest.go
@@ -0,0 +1,150 @@
+/*
+Package autorest implements an HTTP request pipeline suitable for use across multiple go-routines
+and provides the shared routines relied on by AutoRest (see https://github.com/Azure/autorest/)
+generated Go code.
+
+The package breaks sending and responding to HTTP requests into three phases: Preparing, Sending,
+and Responding. A typical pattern is:
+
+ req, err := Prepare(&http.Request{},
+ token.WithAuthorization())
+
+ resp, err := Send(req,
+ WithLogging(logger),
+ DoErrorIfStatusCode(http.StatusInternalServerError),
+ DoCloseIfError(),
+ DoRetryForAttempts(5, time.Second))
+
+ err = Respond(resp,
+ ByDiscardingBody(),
+ ByClosing())
+
+Each phase relies on decorators to modify and / or manage processing. Decorators may first modify
+and then pass the data along, pass the data first and then modify the result, or wrap themselves
+around passing the data (such as a logger might do). Decorators run in the order provided. For
+example, the following:
+
+ req, err := Prepare(&http.Request{},
+ WithBaseURL("https://microsoft.com/"),
+ WithPath("a"),
+ WithPath("b"),
+ WithPath("c"))
+
+will set the URL to:
+
+ https://microsoft.com/a/b/c
+
+Preparers and Responders may be shared and re-used (assuming the underlying decorators support
+sharing and re-use). Performant use is obtained by creating one or more Preparers and Responders
+shared among multiple go-routines, and a single Sender shared among multiple sending go-routines,
+all bound together by means of input / output channels.
+
+Decorators hold their passed state within a closure (such as the path components in the example
+above). Be careful to share Preparers and Responders only in a context where such held state
+applies. For example, it may not make sense to share a Preparer that applies a query string from a
+fixed set of values. Similarly, sharing a Responder that reads the response body into a passed
+struct (e.g., ByUnmarshallingJson) is likely incorrect.
+
+Lastly, the Swagger specification (https://swagger.io) that drives AutoRest
+(https://github.com/Azure/autorest/) precisely defines two date forms: date and date-time. The
+github.com/Azure/go-autorest/autorest/date package provides time.Time derivations to ensure
+correct parsing and formatting.
+
+Errors raised by autorest objects and methods will conform to the autorest.Error interface.
+
+See the included examples for more detail. For details on the suggested use of this package by
+generated clients, see the Client described below.
+*/
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "context"
+ "net/http"
+ "time"
+)
+
+const (
+ // HeaderLocation specifies the HTTP Location header.
+ HeaderLocation = "Location"
+
+ // HeaderRetryAfter specifies the HTTP Retry-After header.
+ HeaderRetryAfter = "Retry-After"
+)
+
+// ResponseHasStatusCode returns true if the status code in the HTTP Response is in the passed set
+// and false otherwise.
+func ResponseHasStatusCode(resp *http.Response, codes ...int) bool {
+ if resp == nil {
+ return false
+ }
+ return containsInt(codes, resp.StatusCode)
+}
+
+// GetLocation retrieves the URL from the Location header of the passed response.
+func GetLocation(resp *http.Response) string {
+ return resp.Header.Get(HeaderLocation)
+}
+
+// GetRetryAfter extracts the retry delay from the Retry-After header of the passed response. If
+// the header is absent or is malformed, it will return the supplied default delay time.Duration.
+func GetRetryAfter(resp *http.Response, defaultDelay time.Duration) time.Duration {
+ retry := resp.Header.Get(HeaderRetryAfter)
+ if retry == "" {
+ return defaultDelay
+ }
+
+ d, err := time.ParseDuration(retry + "s")
+ if err != nil {
+ return defaultDelay
+ }
+
+ return d
+}
+
+// NewPollingRequest allocates and returns a new http.Request to poll for the passed response.
+func NewPollingRequest(resp *http.Response, cancel <-chan struct{}) (*http.Request, error) {
+ location := GetLocation(resp)
+ if location == "" {
+ return nil, NewErrorWithResponse("autorest", "NewPollingRequest", resp, "Location header missing from response that requires polling")
+ }
+
+ req, err := Prepare(&http.Request{Cancel: cancel},
+ AsGet(),
+ WithBaseURL(location))
+ if err != nil {
+ return nil, NewErrorWithError(err, "autorest", "NewPollingRequest", nil, "Failure creating poll request to %s", location)
+ }
+
+ return req, nil
+}
+
+// NewPollingRequestWithContext allocates and returns a new http.Request with the specified context to poll for the passed response.
+func NewPollingRequestWithContext(ctx context.Context, resp *http.Response) (*http.Request, error) {
+ location := GetLocation(resp)
+ if location == "" {
+ return nil, NewErrorWithResponse("autorest", "NewPollingRequestWithContext", resp, "Location header missing from response that requires polling")
+ }
+
+ req, err := Prepare((&http.Request{}).WithContext(ctx),
+ AsGet(),
+ WithBaseURL(location))
+ if err != nil {
+ return nil, NewErrorWithError(err, "autorest", "NewPollingRequestWithContext", nil, "Failure creating poll request to %s", location)
+ }
+
+ return req, nil
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/async.go b/vendor/github.com/Azure/go-autorest/autorest/azure/async.go
new file mode 100644
index 0000000000..0041eacf75
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/async.go
@@ -0,0 +1,992 @@
+package azure
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/tracing"
+)
+
+const (
+ headerAsyncOperation = "Azure-AsyncOperation"
+)
+
+const (
+ operationInProgress string = "InProgress"
+ operationCanceled string = "Canceled"
+ operationFailed string = "Failed"
+ operationSucceeded string = "Succeeded"
+)
+
+var pollingCodes = [...]int{http.StatusNoContent, http.StatusAccepted, http.StatusCreated, http.StatusOK}
+
+// Future provides a mechanism to access the status and results of an asynchronous request.
+// Since futures are stateful they should be passed by value to avoid race conditions.
+type Future struct {
+ req *http.Request // legacy
+ pt pollingTracker
+}
+
+// NewFuture returns a new Future object initialized with the specified request.
+// Deprecated: Please use NewFutureFromResponse instead.
+func NewFuture(req *http.Request) Future {
+ return Future{req: req}
+}
+
+// NewFutureFromResponse returns a new Future object initialized
+// with the initial response from an asynchronous operation.
+func NewFutureFromResponse(resp *http.Response) (Future, error) {
+ pt, err := createPollingTracker(resp)
+ return Future{pt: pt}, err
+}
+
+// Response returns the last HTTP response.
+func (f Future) Response() *http.Response {
+ if f.pt == nil {
+ return nil
+ }
+ return f.pt.latestResponse()
+}
+
+// Status returns the last status message of the operation.
+func (f Future) Status() string {
+ if f.pt == nil {
+ return ""
+ }
+ return f.pt.pollingStatus()
+}
+
+// PollingMethod returns the method used to monitor the status of the asynchronous operation.
+func (f Future) PollingMethod() PollingMethodType {
+ if f.pt == nil {
+ return PollingUnknown
+ }
+ return f.pt.pollingMethod()
+}
+
+// Done queries the service to see if the operation has completed.
+// Deprecated: Use DoneWithContext()
+func (f *Future) Done(sender autorest.Sender) (bool, error) {
+ return f.DoneWithContext(context.Background(), sender)
+}
+
+// DoneWithContext queries the service to see if the operation has completed.
+func (f *Future) DoneWithContext(ctx context.Context, sender autorest.Sender) (done bool, err error) {
+ ctx = tracing.StartSpan(ctx, "github.com/Azure/go-autorest/autorest/azure/async.DoneWithContext")
+ defer func() {
+ sc := -1
+ resp := f.Response()
+ if resp != nil {
+ sc = resp.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+
+ // support for legacy Future implementation
+ if f.req != nil {
+ resp, err := sender.Do(f.req)
+ if err != nil {
+ return false, err
+ }
+ pt, err := createPollingTracker(resp)
+ if err != nil {
+ return false, err
+ }
+ f.pt = pt
+ f.req = nil
+ }
+ // end legacy
+ if f.pt == nil {
+ return false, autorest.NewError("Future", "Done", "future is not initialized")
+ }
+ if f.pt.hasTerminated() {
+ return true, f.pt.pollingError()
+ }
+ if err := f.pt.pollForStatus(ctx, sender); err != nil {
+ return false, err
+ }
+ if err := f.pt.checkForErrors(); err != nil {
+ return f.pt.hasTerminated(), err
+ }
+ if err := f.pt.updatePollingState(f.pt.provisioningStateApplicable()); err != nil {
+ return false, err
+ }
+ if err := f.pt.initPollingMethod(); err != nil {
+ return false, err
+ }
+ if err := f.pt.updatePollingMethod(); err != nil {
+ return false, err
+ }
+ return f.pt.hasTerminated(), f.pt.pollingError()
+}
+
+// GetPollingDelay returns a duration the application should wait before checking
+// the status of the asynchronous request and true; this value is returned from
+// the service via the Retry-After response header. If the header wasn't returned
+// then the function returns the zero-value time.Duration and false.
+func (f Future) GetPollingDelay() (time.Duration, bool) {
+ if f.pt == nil {
+ return 0, false
+ }
+ resp := f.pt.latestResponse()
+ if resp == nil {
+ return 0, false
+ }
+
+ retry := resp.Header.Get(autorest.HeaderRetryAfter)
+ if retry == "" {
+ return 0, false
+ }
+
+ d, err := time.ParseDuration(retry + "s")
+ if err != nil {
+ panic(err)
+ }
+
+ return d, true
+}
+
+// WaitForCompletion will return when one of the following conditions is met: the long
+// running operation has completed, the provided context is cancelled, or the client's
+// polling duration has been exceeded. It will retry failed polling attempts based on
+// the retry value defined in the client up to the maximum retry attempts.
+// Deprecated: Please use WaitForCompletionRef() instead.
+func (f Future) WaitForCompletion(ctx context.Context, client autorest.Client) error {
+ return f.WaitForCompletionRef(ctx, client)
+}
+
+// WaitForCompletionRef will return when one of the following conditions is met: the long
+// running operation has completed, the provided context is cancelled, or the client's
+// polling duration has been exceeded. It will retry failed polling attempts based on
+// the retry value defined in the client up to the maximum retry attempts.
+// If no deadline is specified in the context then the client.PollingDuration will be
+// used to determine if a default deadline should be used.
+// If PollingDuration is greater than zero the value will be used as the context's timeout.
+// If PollingDuration is zero then no default deadline will be used.
+func (f *Future) WaitForCompletionRef(ctx context.Context, client autorest.Client) (err error) {
+ ctx = tracing.StartSpan(ctx, "github.com/Azure/go-autorest/autorest/azure/async.WaitForCompletionRef")
+ defer func() {
+ sc := -1
+ resp := f.Response()
+ if resp != nil {
+ sc = resp.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ cancelCtx := ctx
+ // if the provided context already has a deadline don't override it
+ _, hasDeadline := ctx.Deadline()
+ if d := client.PollingDuration; !hasDeadline && d != 0 {
+ var cancel context.CancelFunc
+ cancelCtx, cancel = context.WithTimeout(ctx, d)
+ defer cancel()
+ }
+
+ done, err := f.DoneWithContext(ctx, client)
+ for attempts := 0; !done; done, err = f.DoneWithContext(ctx, client) {
+ if attempts >= client.RetryAttempts {
+ return autorest.NewErrorWithError(err, "Future", "WaitForCompletion", f.pt.latestResponse(), "the number of retries has been exceeded")
+ }
+ // we want delayAttempt to be zero in the non-error case so
+ // that DelayForBackoff doesn't perform exponential back-off
+ var delayAttempt int
+ var delay time.Duration
+ if err == nil {
+ // check for Retry-After delay, if not present use the client's polling delay
+ var ok bool
+ delay, ok = f.GetPollingDelay()
+ if !ok {
+ delay = client.PollingDelay
+ }
+ } else {
+ // there was an error polling for status so perform exponential
+ // back-off based on the number of attempts using the client's retry
+ // duration. update attempts after delayAttempt to avoid off-by-one.
+ delayAttempt = attempts
+ delay = client.RetryDuration
+ attempts++
+ }
+ // wait until the delay elapses or the context is cancelled
+ delayElapsed := autorest.DelayForBackoff(delay, delayAttempt, cancelCtx.Done())
+ if !delayElapsed {
+ return autorest.NewErrorWithError(cancelCtx.Err(), "Future", "WaitForCompletion", f.pt.latestResponse(), "context has been cancelled")
+ }
+ }
+ return
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (f Future) MarshalJSON() ([]byte, error) {
+ return json.Marshal(f.pt)
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface.
+func (f *Future) UnmarshalJSON(data []byte) error {
+ // unmarshal into JSON object to determine the tracker type
+ obj := map[string]interface{}{}
+ err := json.Unmarshal(data, &obj)
+ if err != nil {
+ return err
+ }
+ if obj["method"] == nil {
+ return autorest.NewError("Future", "UnmarshalJSON", "missing 'method' property")
+ }
+ method := obj["method"].(string)
+ switch strings.ToUpper(method) {
+ case http.MethodDelete:
+ f.pt = &pollingTrackerDelete{}
+ case http.MethodPatch:
+ f.pt = &pollingTrackerPatch{}
+ case http.MethodPost:
+ f.pt = &pollingTrackerPost{}
+ case http.MethodPut:
+ f.pt = &pollingTrackerPut{}
+ default:
+ return autorest.NewError("Future", "UnmarshalJSON", "unsupoorted method '%s'", method)
+ }
+ // now unmarshal into the tracker
+ return json.Unmarshal(data, &f.pt)
+}
+
+// PollingURL returns the URL used for retrieving the status of the long-running operation.
+func (f Future) PollingURL() string {
+ if f.pt == nil {
+ return ""
+ }
+ return f.pt.pollingURL()
+}
+
+// GetResult should be called once polling has completed successfully.
+// It makes the final GET call to retrieve the resultant payload.
+func (f Future) GetResult(sender autorest.Sender) (*http.Response, error) {
+ if f.pt.finalGetURL() == "" {
+ // we can end up in this situation if the async operation returns a 200
+ // with no polling URLs. in that case return the response which should
+ // contain the JSON payload (only do this for successful terminal cases).
+ if lr := f.pt.latestResponse(); lr != nil && f.pt.hasSucceeded() {
+ return lr, nil
+ }
+ return nil, autorest.NewError("Future", "GetResult", "missing URL for retrieving result")
+ }
+ req, err := http.NewRequest(http.MethodGet, f.pt.finalGetURL(), nil)
+ if err != nil {
+ return nil, err
+ }
+ return sender.Do(req)
+}
+
+type pollingTracker interface {
+ // these methods can differ per tracker
+
+ // checks the response headers and status code to determine the polling mechanism
+ updatePollingMethod() error
+
+ // checks the response for tracker-specific error conditions
+ checkForErrors() error
+
+ // returns true if provisioning state should be checked
+ provisioningStateApplicable() bool
+
+ // methods common to all trackers
+
+ // initializes a tracker's polling URL and method, called for each iteration.
+ // these values can be overridden by each polling tracker as required.
+ initPollingMethod() error
+
+ // initializes the tracker's internal state, call this when the tracker is created
+ initializeState() error
+
+ // makes an HTTP request to check the status of the LRO
+ pollForStatus(ctx context.Context, sender autorest.Sender) error
+
+ // updates internal tracker state, call this after each call to pollForStatus
+ updatePollingState(provStateApl bool) error
+
+ // returns the error response from the service, can be nil
+ pollingError() error
+
+ // returns the polling method being used
+ pollingMethod() PollingMethodType
+
+ // returns the state of the LRO as returned from the service
+ pollingStatus() string
+
+ // returns the URL used for polling status
+ pollingURL() string
+
+ // returns the URL used for the final GET to retrieve the resource
+ finalGetURL() string
+
+ // returns true if the LRO is in a terminal state
+ hasTerminated() bool
+
+ // returns true if the LRO is in a failed terminal state
+ hasFailed() bool
+
+ // returns true if the LRO is in a successful terminal state
+ hasSucceeded() bool
+
+ // returns the cached HTTP response after a call to pollForStatus(), can be nil
+ latestResponse() *http.Response
+}
+
+type pollingTrackerBase struct {
+ // resp is the last response, either from the submission of the LRO or from polling
+ resp *http.Response
+
+ // method is the HTTP verb, this is needed for deserialization
+ Method string `json:"method"`
+
+ // rawBody is the raw JSON response body
+ rawBody map[string]interface{}
+
+ // denotes if polling is using async-operation or location header
+ Pm PollingMethodType `json:"pollingMethod"`
+
+ // the URL to poll for status
+ URI string `json:"pollingURI"`
+
+ // the state of the LRO as returned from the service
+ State string `json:"lroState"`
+
+ // the URL to GET for the final result
+ FinalGetURI string `json:"resultURI"`
+
+ // used to hold an error object returned from the service
+ Err *ServiceError `json:"error,omitempty"`
+}
+
+func (pt *pollingTrackerBase) initializeState() error {
+ // determine the initial polling state based on response body and/or HTTP status
+ // code. this is applicable to the initial LRO response, not polling responses!
+ pt.Method = pt.resp.Request.Method
+ if err := pt.updateRawBody(); err != nil {
+ return err
+ }
+ switch pt.resp.StatusCode {
+ case http.StatusOK:
+ if ps := pt.getProvisioningState(); ps != nil {
+ pt.State = *ps
+ if pt.hasFailed() {
+ pt.updateErrorFromResponse()
+ return pt.pollingError()
+ }
+ } else {
+ pt.State = operationSucceeded
+ }
+ case http.StatusCreated:
+ if ps := pt.getProvisioningState(); ps != nil {
+ pt.State = *ps
+ } else {
+ pt.State = operationInProgress
+ }
+ case http.StatusAccepted:
+ pt.State = operationInProgress
+ case http.StatusNoContent:
+ pt.State = operationSucceeded
+ default:
+ pt.State = operationFailed
+ pt.updateErrorFromResponse()
+ return pt.pollingError()
+ }
+ return pt.initPollingMethod()
+}
+
+func (pt pollingTrackerBase) getProvisioningState() *string {
+ if pt.rawBody != nil && pt.rawBody["properties"] != nil {
+ p := pt.rawBody["properties"].(map[string]interface{})
+ if ps := p["provisioningState"]; ps != nil {
+ s := ps.(string)
+ return &s
+ }
+ }
+ return nil
+}
+
+func (pt *pollingTrackerBase) updateRawBody() error {
+ pt.rawBody = map[string]interface{}{}
+ if pt.resp.ContentLength != 0 {
+ defer pt.resp.Body.Close()
+ b, err := ioutil.ReadAll(pt.resp.Body)
+ if err != nil {
+ return autorest.NewErrorWithError(err, "pollingTrackerBase", "updateRawBody", nil, "failed to read response body")
+ }
+ // observed in 204 responses over HTTP/2.0; the content length is -1 but body is empty
+ if len(b) == 0 {
+ return nil
+ }
+ // put the body back so it's available to other callers
+ pt.resp.Body = ioutil.NopCloser(bytes.NewReader(b))
+ if err = json.Unmarshal(b, &pt.rawBody); err != nil {
+ return autorest.NewErrorWithError(err, "pollingTrackerBase", "updateRawBody", nil, "failed to unmarshal response body")
+ }
+ }
+ return nil
+}
+
+func (pt *pollingTrackerBase) pollForStatus(ctx context.Context, sender autorest.Sender) error {
+ req, err := http.NewRequest(http.MethodGet, pt.URI, nil)
+ if err != nil {
+ return autorest.NewErrorWithError(err, "pollingTrackerBase", "pollForStatus", nil, "failed to create HTTP request")
+ }
+
+ req = req.WithContext(ctx)
+ pt.resp, err = sender.Do(req)
+ if err != nil {
+ return autorest.NewErrorWithError(err, "pollingTrackerBase", "pollForStatus", nil, "failed to send HTTP request")
+ }
+ if autorest.ResponseHasStatusCode(pt.resp, pollingCodes[:]...) {
+ // reset the service error on success case
+ pt.Err = nil
+ err = pt.updateRawBody()
+ } else {
+ // check response body for error content
+ pt.updateErrorFromResponse()
+ err = pt.pollingError()
+ }
+ return err
+}
+
+// attempts to unmarshal a ServiceError type from the response body.
+// if that fails then make a best attempt at creating something meaningful.
+// NOTE: this assumes that the async operation has failed.
+func (pt *pollingTrackerBase) updateErrorFromResponse() {
+ var err error
+ if pt.resp.ContentLength != 0 {
+ type respErr struct {
+ ServiceError *ServiceError `json:"error"`
+ }
+ re := respErr{}
+ defer pt.resp.Body.Close()
+ var b []byte
+ if b, err = ioutil.ReadAll(pt.resp.Body); err != nil || len(b) == 0 {
+ goto Default
+ }
+ if err = json.Unmarshal(b, &re); err != nil {
+ goto Default
+ }
+ // unmarshalling the error didn't yield anything, try unwrapped error
+ if re.ServiceError == nil {
+ err = json.Unmarshal(b, &re.ServiceError)
+ if err != nil {
+ goto Default
+ }
+ }
+ // the unmarshaller will ensure re.ServiceError is non-nil
+ // even if there was no content unmarshalled so check the code.
+ if re.ServiceError.Code != "" {
+ pt.Err = re.ServiceError
+ return
+ }
+ }
+Default:
+ se := &ServiceError{
+ Code: pt.pollingStatus(),
+ Message: "The async operation failed.",
+ }
+ if err != nil {
+ se.InnerError = make(map[string]interface{})
+ se.InnerError["unmarshalError"] = err.Error()
+ }
+ // stick the response body into the error object in hopes
+ // it contains something useful to help diagnose the failure.
+ if len(pt.rawBody) > 0 {
+ se.AdditionalInfo = []map[string]interface{}{
+ pt.rawBody,
+ }
+ }
+ pt.Err = se
+}
+
+func (pt *pollingTrackerBase) updatePollingState(provStateApl bool) error {
+ if pt.Pm == PollingAsyncOperation && pt.rawBody["status"] != nil {
+ pt.State = pt.rawBody["status"].(string)
+ } else {
+ if pt.resp.StatusCode == http.StatusAccepted {
+ pt.State = operationInProgress
+ } else if provStateApl {
+ if ps := pt.getProvisioningState(); ps != nil {
+ pt.State = *ps
+ } else {
+ pt.State = operationSucceeded
+ }
+ } else {
+ return autorest.NewError("pollingTrackerBase", "updatePollingState", "the response from the async operation has an invalid status code")
+ }
+ }
+ // if the operation has failed update the error state
+ if pt.hasFailed() {
+ pt.updateErrorFromResponse()
+ }
+ return nil
+}
+
+func (pt pollingTrackerBase) pollingError() error {
+ if pt.Err == nil {
+ return nil
+ }
+ return pt.Err
+}
+
+func (pt pollingTrackerBase) pollingMethod() PollingMethodType {
+ return pt.Pm
+}
+
+func (pt pollingTrackerBase) pollingStatus() string {
+ return pt.State
+}
+
+func (pt pollingTrackerBase) pollingURL() string {
+ return pt.URI
+}
+
+func (pt pollingTrackerBase) finalGetURL() string {
+ return pt.FinalGetURI
+}
+
+func (pt pollingTrackerBase) hasTerminated() bool {
+ return strings.EqualFold(pt.State, operationCanceled) || strings.EqualFold(pt.State, operationFailed) || strings.EqualFold(pt.State, operationSucceeded)
+}
+
+func (pt pollingTrackerBase) hasFailed() bool {
+ return strings.EqualFold(pt.State, operationCanceled) || strings.EqualFold(pt.State, operationFailed)
+}
+
+func (pt pollingTrackerBase) hasSucceeded() bool {
+ return strings.EqualFold(pt.State, operationSucceeded)
+}
+
+func (pt pollingTrackerBase) latestResponse() *http.Response {
+ return pt.resp
+}
+
+// error checking common to all trackers
+func (pt pollingTrackerBase) baseCheckForErrors() error {
+ // for Azure-AsyncOperations the response body cannot be nil or empty
+ if pt.Pm == PollingAsyncOperation {
+ if pt.resp.Body == nil || pt.resp.ContentLength == 0 {
+ return autorest.NewError("pollingTrackerBase", "baseCheckForErrors", "for Azure-AsyncOperation response body cannot be nil")
+ }
+ if pt.rawBody["status"] == nil {
+ return autorest.NewError("pollingTrackerBase", "baseCheckForErrors", "missing status property in Azure-AsyncOperation response body")
+ }
+ }
+ return nil
+}
+
+// default initialization of polling URL/method. each verb tracker will update this as required.
+func (pt *pollingTrackerBase) initPollingMethod() error {
+ if ao, err := getURLFromAsyncOpHeader(pt.resp); err != nil {
+ return err
+ } else if ao != "" {
+ pt.URI = ao
+ pt.Pm = PollingAsyncOperation
+ return nil
+ }
+ if lh, err := getURLFromLocationHeader(pt.resp); err != nil {
+ return err
+ } else if lh != "" {
+ pt.URI = lh
+ pt.Pm = PollingLocation
+ return nil
+ }
+ // it's ok if we didn't find a polling header, this will be handled elsewhere
+ return nil
+}
+
+// DELETE
+
+type pollingTrackerDelete struct {
+ pollingTrackerBase
+}
+
+func (pt *pollingTrackerDelete) updatePollingMethod() error {
+ // for 201 the Location header is required
+ if pt.resp.StatusCode == http.StatusCreated {
+ if lh, err := getURLFromLocationHeader(pt.resp); err != nil {
+ return err
+ } else if lh == "" {
+ return autorest.NewError("pollingTrackerDelete", "updateHeaders", "missing Location header in 201 response")
+ } else {
+ pt.URI = lh
+ }
+ pt.Pm = PollingLocation
+ pt.FinalGetURI = pt.URI
+ }
+ // for 202 prefer the Azure-AsyncOperation header but fall back to Location if necessary
+ if pt.resp.StatusCode == http.StatusAccepted {
+ ao, err := getURLFromAsyncOpHeader(pt.resp)
+ if err != nil {
+ return err
+ } else if ao != "" {
+ pt.URI = ao
+ pt.Pm = PollingAsyncOperation
+ }
+ // if the Location header is invalid and we already have a polling URL
+ // then we don't care if the Location header URL is malformed.
+ if lh, err := getURLFromLocationHeader(pt.resp); err != nil && pt.URI == "" {
+ return err
+ } else if lh != "" {
+ if ao == "" {
+ pt.URI = lh
+ pt.Pm = PollingLocation
+ }
+ // when both headers are returned we use the value in the Location header for the final GET
+ pt.FinalGetURI = lh
+ }
+ // make sure a polling URL was found
+ if pt.URI == "" {
+ return autorest.NewError("pollingTrackerPost", "updateHeaders", "didn't get any suitable polling URLs in 202 response")
+ }
+ }
+ return nil
+}
+
+func (pt pollingTrackerDelete) checkForErrors() error {
+ return pt.baseCheckForErrors()
+}
+
+func (pt pollingTrackerDelete) provisioningStateApplicable() bool {
+ return pt.resp.StatusCode == http.StatusOK || pt.resp.StatusCode == http.StatusNoContent
+}
+
+// PATCH
+
+type pollingTrackerPatch struct {
+ pollingTrackerBase
+}
+
+func (pt *pollingTrackerPatch) updatePollingMethod() error {
+ // by default we can use the original URL for polling and final GET
+ if pt.URI == "" {
+ pt.URI = pt.resp.Request.URL.String()
+ }
+ if pt.FinalGetURI == "" {
+ pt.FinalGetURI = pt.resp.Request.URL.String()
+ }
+ if pt.Pm == PollingUnknown {
+ pt.Pm = PollingRequestURI
+ }
+ // for 201 it's permissible for no headers to be returned
+ if pt.resp.StatusCode == http.StatusCreated {
+ if ao, err := getURLFromAsyncOpHeader(pt.resp); err != nil {
+ return err
+ } else if ao != "" {
+ pt.URI = ao
+ pt.Pm = PollingAsyncOperation
+ }
+ }
+ // for 202 prefer the Azure-AsyncOperation header but fall back to Location if necessary
+ // note the absence of the "final GET" mechanism for PATCH
+ if pt.resp.StatusCode == http.StatusAccepted {
+ ao, err := getURLFromAsyncOpHeader(pt.resp)
+ if err != nil {
+ return err
+ } else if ao != "" {
+ pt.URI = ao
+ pt.Pm = PollingAsyncOperation
+ }
+ if ao == "" {
+ if lh, err := getURLFromLocationHeader(pt.resp); err != nil {
+ return err
+ } else if lh == "" {
+ return autorest.NewError("pollingTrackerPatch", "updateHeaders", "didn't get any suitable polling URLs in 202 response")
+ } else {
+ pt.URI = lh
+ pt.Pm = PollingLocation
+ }
+ }
+ }
+ return nil
+}
+
+func (pt pollingTrackerPatch) checkForErrors() error {
+ return pt.baseCheckForErrors()
+}
+
+func (pt pollingTrackerPatch) provisioningStateApplicable() bool {
+ return pt.resp.StatusCode == http.StatusOK || pt.resp.StatusCode == http.StatusCreated
+}
+
+// POST
+
+type pollingTrackerPost struct {
+ pollingTrackerBase
+}
+
+func (pt *pollingTrackerPost) updatePollingMethod() error {
+ // 201 requires Location header
+ if pt.resp.StatusCode == http.StatusCreated {
+ if lh, err := getURLFromLocationHeader(pt.resp); err != nil {
+ return err
+ } else if lh == "" {
+ return autorest.NewError("pollingTrackerPost", "updateHeaders", "missing Location header in 201 response")
+ } else {
+ pt.URI = lh
+ pt.FinalGetURI = lh
+ pt.Pm = PollingLocation
+ }
+ }
+ // for 202 prefer the Azure-AsyncOperation header but fall back to Location if necessary
+ if pt.resp.StatusCode == http.StatusAccepted {
+ ao, err := getURLFromAsyncOpHeader(pt.resp)
+ if err != nil {
+ return err
+ } else if ao != "" {
+ pt.URI = ao
+ pt.Pm = PollingAsyncOperation
+ }
+ // if the Location header is invalid and we already have a polling URL
+ // then we don't care if the Location header URL is malformed.
+ if lh, err := getURLFromLocationHeader(pt.resp); err != nil && pt.URI == "" {
+ return err
+ } else if lh != "" {
+ if ao == "" {
+ pt.URI = lh
+ pt.Pm = PollingLocation
+ }
+ // when both headers are returned we use the value in the Location header for the final GET
+ pt.FinalGetURI = lh
+ }
+ // make sure a polling URL was found
+ if pt.URI == "" {
+ return autorest.NewError("pollingTrackerPost", "updateHeaders", "didn't get any suitable polling URLs in 202 response")
+ }
+ }
+ return nil
+}
+
+func (pt pollingTrackerPost) checkForErrors() error {
+ return pt.baseCheckForErrors()
+}
+
+func (pt pollingTrackerPost) provisioningStateApplicable() bool {
+ return pt.resp.StatusCode == http.StatusOK || pt.resp.StatusCode == http.StatusNoContent
+}
+
+// PUT
+
+type pollingTrackerPut struct {
+ pollingTrackerBase
+}
+
+func (pt *pollingTrackerPut) updatePollingMethod() error {
+ // by default we can use the original URL for polling and final GET
+ if pt.URI == "" {
+ pt.URI = pt.resp.Request.URL.String()
+ }
+ if pt.FinalGetURI == "" {
+ pt.FinalGetURI = pt.resp.Request.URL.String()
+ }
+ if pt.Pm == PollingUnknown {
+ pt.Pm = PollingRequestURI
+ }
+ // for 201 it's permissible for no headers to be returned
+ if pt.resp.StatusCode == http.StatusCreated {
+ if ao, err := getURLFromAsyncOpHeader(pt.resp); err != nil {
+ return err
+ } else if ao != "" {
+ pt.URI = ao
+ pt.Pm = PollingAsyncOperation
+ }
+ }
+ // for 202 prefer the Azure-AsyncOperation header but fall back to Location if necessary
+ if pt.resp.StatusCode == http.StatusAccepted {
+ ao, err := getURLFromAsyncOpHeader(pt.resp)
+ if err != nil {
+ return err
+ } else if ao != "" {
+ pt.URI = ao
+ pt.Pm = PollingAsyncOperation
+ }
+ // if the Location header is invalid and we already have a polling URL
+ // then we don't care if the Location header URL is malformed.
+ if lh, err := getURLFromLocationHeader(pt.resp); err != nil && pt.URI == "" {
+ return err
+ } else if lh != "" {
+ if ao == "" {
+ pt.URI = lh
+ pt.Pm = PollingLocation
+ }
+ }
+ // make sure a polling URL was found
+ if pt.URI == "" {
+ return autorest.NewError("pollingTrackerPut", "updateHeaders", "didn't get any suitable polling URLs in 202 response")
+ }
+ }
+ return nil
+}
+
+func (pt pollingTrackerPut) checkForErrors() error {
+ err := pt.baseCheckForErrors()
+ if err != nil {
+ return err
+ }
+ // if there are no LRO headers then the body cannot be empty
+ ao, err := getURLFromAsyncOpHeader(pt.resp)
+ if err != nil {
+ return err
+ }
+ lh, err := getURLFromLocationHeader(pt.resp)
+ if err != nil {
+ return err
+ }
+ if ao == "" && lh == "" && len(pt.rawBody) == 0 {
+ return autorest.NewError("pollingTrackerPut", "checkForErrors", "the response did not contain a body")
+ }
+ return nil
+}
+
+func (pt pollingTrackerPut) provisioningStateApplicable() bool {
+ return pt.resp.StatusCode == http.StatusOK || pt.resp.StatusCode == http.StatusCreated
+}
+
+// creates a polling tracker based on the verb of the original request
+func createPollingTracker(resp *http.Response) (pollingTracker, error) {
+ var pt pollingTracker
+ switch strings.ToUpper(resp.Request.Method) {
+ case http.MethodDelete:
+ pt = &pollingTrackerDelete{pollingTrackerBase: pollingTrackerBase{resp: resp}}
+ case http.MethodPatch:
+ pt = &pollingTrackerPatch{pollingTrackerBase: pollingTrackerBase{resp: resp}}
+ case http.MethodPost:
+ pt = &pollingTrackerPost{pollingTrackerBase: pollingTrackerBase{resp: resp}}
+ case http.MethodPut:
+ pt = &pollingTrackerPut{pollingTrackerBase: pollingTrackerBase{resp: resp}}
+ default:
+ return nil, autorest.NewError("azure", "createPollingTracker", "unsupported HTTP method %s", resp.Request.Method)
+ }
+ if err := pt.initializeState(); err != nil {
+ return pt, err
+ }
+ // this initializes the polling header values, we do this during creation in case the
+ // initial response send us invalid values; this way the API call will return a non-nil
+ // error (not doing this means the error shows up in Future.Done)
+ return pt, pt.updatePollingMethod()
+}
+
+// gets the polling URL from the Azure-AsyncOperation header.
+// ensures the URL is well-formed and absolute.
+func getURLFromAsyncOpHeader(resp *http.Response) (string, error) {
+ s := resp.Header.Get(http.CanonicalHeaderKey(headerAsyncOperation))
+ if s == "" {
+ return "", nil
+ }
+ if !isValidURL(s) {
+ return "", autorest.NewError("azure", "getURLFromAsyncOpHeader", "invalid polling URL '%s'", s)
+ }
+ return s, nil
+}
+
+// gets the polling URL from the Location header.
+// ensures the URL is well-formed and absolute.
+func getURLFromLocationHeader(resp *http.Response) (string, error) {
+ s := resp.Header.Get(http.CanonicalHeaderKey(autorest.HeaderLocation))
+ if s == "" {
+ return "", nil
+ }
+ if !isValidURL(s) {
+ return "", autorest.NewError("azure", "getURLFromLocationHeader", "invalid polling URL '%s'", s)
+ }
+ return s, nil
+}
+
+// verify that the URL is valid and absolute
+func isValidURL(s string) bool {
+ u, err := url.Parse(s)
+ return err == nil && u.IsAbs()
+}
+
+// DoPollForAsynchronous returns a SendDecorator that polls if the http.Response is for an Azure
+// long-running operation. It will delay between requests for the duration specified in the
+// RetryAfter header or, if the header is absent, the passed delay. Polling may be canceled via
+// the context associated with the http.Request.
+// Deprecated: Prefer using Futures to allow for non-blocking async operations.
+func DoPollForAsynchronous(delay time.Duration) autorest.SendDecorator {
+ return func(s autorest.Sender) autorest.Sender {
+ return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
+ resp, err := s.Do(r)
+ if err != nil {
+ return resp, err
+ }
+ if !autorest.ResponseHasStatusCode(resp, pollingCodes[:]...) {
+ return resp, nil
+ }
+ future, err := NewFutureFromResponse(resp)
+ if err != nil {
+ return resp, err
+ }
+ // retry until either the LRO completes or we receive an error
+ var done bool
+ for done, err = future.Done(s); !done && err == nil; done, err = future.Done(s) {
+ // check for Retry-After delay, if not present use the specified polling delay
+ if pd, ok := future.GetPollingDelay(); ok {
+ delay = pd
+ }
+ // wait until the delay elapses or the context is cancelled
+ if delayElapsed := autorest.DelayForBackoff(delay, 0, r.Context().Done()); !delayElapsed {
+ return future.Response(),
+ autorest.NewErrorWithError(r.Context().Err(), "azure", "DoPollForAsynchronous", future.Response(), "context has been cancelled")
+ }
+ }
+ return future.Response(), err
+ })
+ }
+}
+
+// PollingMethodType defines a type used for enumerating polling mechanisms.
+type PollingMethodType string
+
+const (
+ // PollingAsyncOperation indicates the polling method uses the Azure-AsyncOperation header.
+ PollingAsyncOperation PollingMethodType = "AsyncOperation"
+
+ // PollingLocation indicates the polling method uses the Location header.
+ PollingLocation PollingMethodType = "Location"
+
+ // PollingRequestURI indicates the polling method uses the original request URI.
+ PollingRequestURI PollingMethodType = "RequestURI"
+
+ // PollingUnknown indicates an unknown polling method and is the default value.
+ PollingUnknown PollingMethodType = ""
+)
+
+// AsyncOpIncompleteError is the type that's returned from a future that has not completed.
+type AsyncOpIncompleteError struct {
+ // FutureType is the name of the type composed of a azure.Future.
+ FutureType string
+}
+
+// Error returns an error message including the originating type name of the error.
+func (e AsyncOpIncompleteError) Error() string {
+ return fmt.Sprintf("%s: asynchronous operation has not completed", e.FutureType)
+}
+
+// NewAsyncOpIncompleteError creates a new AsyncOpIncompleteError with the specified parameters.
+func NewAsyncOpIncompleteError(futureType string) AsyncOpIncompleteError {
+ return AsyncOpIncompleteError{
+ FutureType: futureType,
+ }
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go b/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go
new file mode 100644
index 0000000000..5fc27ef447
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go
@@ -0,0 +1,664 @@
+package auth
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "crypto/rsa"
+ "crypto/x509"
+ "encoding/binary"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "os"
+ "strings"
+ "unicode/utf16"
+
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/adal"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/azure/cli"
+ "github.com/dimchansky/utfbom"
+ "golang.org/x/crypto/pkcs12"
+)
+
+// The possible keys in the Values map.
+const (
+ SubscriptionID = "AZURE_SUBSCRIPTION_ID"
+ TenantID = "AZURE_TENANT_ID"
+ ClientID = "AZURE_CLIENT_ID"
+ ClientSecret = "AZURE_CLIENT_SECRET"
+ CertificatePath = "AZURE_CERTIFICATE_PATH"
+ CertificatePassword = "AZURE_CERTIFICATE_PASSWORD"
+ Username = "AZURE_USERNAME"
+ Password = "AZURE_PASSWORD"
+ EnvironmentName = "AZURE_ENVIRONMENT"
+ Resource = "AZURE_AD_RESOURCE"
+ ActiveDirectoryEndpoint = "ActiveDirectoryEndpoint"
+ ResourceManagerEndpoint = "ResourceManagerEndpoint"
+ GraphResourceID = "GraphResourceID"
+ SQLManagementEndpoint = "SQLManagementEndpoint"
+ GalleryEndpoint = "GalleryEndpoint"
+ ManagementEndpoint = "ManagementEndpoint"
+)
+
+// NewAuthorizerFromEnvironment creates an Authorizer configured from environment variables in the order:
+// 1. Client credentials
+// 2. Client certificate
+// 3. Username password
+// 4. MSI
+func NewAuthorizerFromEnvironment() (autorest.Authorizer, error) {
+ settings, err := GetSettingsFromEnvironment()
+ if err != nil {
+ return nil, err
+ }
+ return settings.GetAuthorizer()
+}
+
+// NewAuthorizerFromEnvironmentWithResource creates an Authorizer configured from environment variables in the order:
+// 1. Client credentials
+// 2. Client certificate
+// 3. Username password
+// 4. MSI
+func NewAuthorizerFromEnvironmentWithResource(resource string) (autorest.Authorizer, error) {
+ settings, err := GetSettingsFromEnvironment()
+ if err != nil {
+ return nil, err
+ }
+ settings.Values[Resource] = resource
+ return settings.GetAuthorizer()
+}
+
+// EnvironmentSettings contains the available authentication settings.
+type EnvironmentSettings struct {
+ Values map[string]string
+ Environment azure.Environment
+}
+
+// GetSettingsFromEnvironment returns the available authentication settings from the environment.
+func GetSettingsFromEnvironment() (s EnvironmentSettings, err error) {
+ s = EnvironmentSettings{
+ Values: map[string]string{},
+ }
+ s.setValue(SubscriptionID)
+ s.setValue(TenantID)
+ s.setValue(ClientID)
+ s.setValue(ClientSecret)
+ s.setValue(CertificatePath)
+ s.setValue(CertificatePassword)
+ s.setValue(Username)
+ s.setValue(Password)
+ s.setValue(EnvironmentName)
+ s.setValue(Resource)
+ if v := s.Values[EnvironmentName]; v == "" {
+ s.Environment = azure.PublicCloud
+ } else {
+ s.Environment, err = azure.EnvironmentFromName(v)
+ }
+ if s.Values[Resource] == "" {
+ s.Values[Resource] = s.Environment.ResourceManagerEndpoint
+ }
+ return
+}
+
+// GetSubscriptionID returns the available subscription ID or an empty string.
+func (settings EnvironmentSettings) GetSubscriptionID() string {
+ return settings.Values[SubscriptionID]
+}
+
+// adds the specified environment variable value to the Values map if it exists
+func (settings EnvironmentSettings) setValue(key string) {
+ if v := os.Getenv(key); v != "" {
+ settings.Values[key] = v
+ }
+}
+
+// helper to return client and tenant IDs
+func (settings EnvironmentSettings) getClientAndTenant() (string, string) {
+ clientID := settings.Values[ClientID]
+ tenantID := settings.Values[TenantID]
+ return clientID, tenantID
+}
+
+// GetClientCredentials creates a config object from the available client credentials.
+// An error is returned if no client credentials are available.
+func (settings EnvironmentSettings) GetClientCredentials() (ClientCredentialsConfig, error) {
+ secret := settings.Values[ClientSecret]
+ if secret == "" {
+ return ClientCredentialsConfig{}, errors.New("missing client secret")
+ }
+ clientID, tenantID := settings.getClientAndTenant()
+ config := NewClientCredentialsConfig(clientID, secret, tenantID)
+ config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
+ config.Resource = settings.Values[Resource]
+ return config, nil
+}
+
+// GetClientCertificate creates a config object from the available certificate credentials.
+// An error is returned if no certificate credentials are available.
+func (settings EnvironmentSettings) GetClientCertificate() (ClientCertificateConfig, error) {
+ certPath := settings.Values[CertificatePath]
+ if certPath == "" {
+ return ClientCertificateConfig{}, errors.New("missing certificate path")
+ }
+ certPwd := settings.Values[CertificatePassword]
+ clientID, tenantID := settings.getClientAndTenant()
+ config := NewClientCertificateConfig(certPath, certPwd, clientID, tenantID)
+ config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
+ config.Resource = settings.Values[Resource]
+ return config, nil
+}
+
+// GetUsernamePassword creates a config object from the available username/password credentials.
+// An error is returned if no username/password credentials are available.
+func (settings EnvironmentSettings) GetUsernamePassword() (UsernamePasswordConfig, error) {
+ username := settings.Values[Username]
+ password := settings.Values[Password]
+ if username == "" || password == "" {
+ return UsernamePasswordConfig{}, errors.New("missing username/password")
+ }
+ clientID, tenantID := settings.getClientAndTenant()
+ config := NewUsernamePasswordConfig(username, password, clientID, tenantID)
+ config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
+ config.Resource = settings.Values[Resource]
+ return config, nil
+}
+
+// GetMSI creates a MSI config object from the available client ID.
+func (settings EnvironmentSettings) GetMSI() MSIConfig {
+ config := NewMSIConfig()
+ config.Resource = settings.Values[Resource]
+ config.ClientID = settings.Values[ClientID]
+ return config
+}
+
+// GetDeviceFlow creates a device-flow config object from the available client and tenant IDs.
+func (settings EnvironmentSettings) GetDeviceFlow() DeviceFlowConfig {
+ clientID, tenantID := settings.getClientAndTenant()
+ config := NewDeviceFlowConfig(clientID, tenantID)
+ config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
+ config.Resource = settings.Values[Resource]
+ return config
+}
+
+// GetAuthorizer creates an Authorizer configured from environment variables in the order:
+// 1. Client credentials
+// 2. Client certificate
+// 3. Username password
+// 4. MSI
+func (settings EnvironmentSettings) GetAuthorizer() (autorest.Authorizer, error) {
+ //1.Client Credentials
+ if c, e := settings.GetClientCredentials(); e == nil {
+ return c.Authorizer()
+ }
+
+ //2. Client Certificate
+ if c, e := settings.GetClientCertificate(); e == nil {
+ return c.Authorizer()
+ }
+
+ //3. Username Password
+ if c, e := settings.GetUsernamePassword(); e == nil {
+ return c.Authorizer()
+ }
+
+ // 4. MSI
+ return settings.GetMSI().Authorizer()
+}
+
+// NewAuthorizerFromFile creates an Authorizer configured from a configuration file in the following order.
+// 1. Client credentials
+// 2. Client certificate
+func NewAuthorizerFromFile(baseURI string) (autorest.Authorizer, error) {
+ settings, err := GetSettingsFromFile()
+ if err != nil {
+ return nil, err
+ }
+ if a, err := settings.ClientCredentialsAuthorizer(baseURI); err == nil {
+ return a, err
+ }
+ if a, err := settings.ClientCertificateAuthorizer(baseURI); err == nil {
+ return a, err
+ }
+ return nil, errors.New("auth file missing client and certificate credentials")
+}
+
+// NewAuthorizerFromFileWithResource creates an Authorizer configured from a configuration file in the following order.
+// 1. Client credentials
+// 2. Client certificate
+func NewAuthorizerFromFileWithResource(resource string) (autorest.Authorizer, error) {
+ s, err := GetSettingsFromFile()
+ if err != nil {
+ return nil, err
+ }
+ if a, err := s.ClientCredentialsAuthorizerWithResource(resource); err == nil {
+ return a, err
+ }
+ if a, err := s.ClientCertificateAuthorizerWithResource(resource); err == nil {
+ return a, err
+ }
+ return nil, errors.New("auth file missing client and certificate credentials")
+}
+
+// NewAuthorizerFromCLI creates an Authorizer configured from Azure CLI 2.0 for local development scenarios.
+func NewAuthorizerFromCLI() (autorest.Authorizer, error) {
+ settings, err := GetSettingsFromEnvironment()
+ if err != nil {
+ return nil, err
+ }
+
+ if settings.Values[Resource] == "" {
+ settings.Values[Resource] = settings.Environment.ResourceManagerEndpoint
+ }
+
+ return NewAuthorizerFromCLIWithResource(settings.Values[Resource])
+}
+
+// NewAuthorizerFromCLIWithResource creates an Authorizer configured from Azure CLI 2.0 for local development scenarios.
+func NewAuthorizerFromCLIWithResource(resource string) (autorest.Authorizer, error) {
+ token, err := cli.GetTokenFromCLI(resource)
+ if err != nil {
+ return nil, err
+ }
+
+ adalToken, err := token.ToADALToken()
+ if err != nil {
+ return nil, err
+ }
+
+ return autorest.NewBearerAuthorizer(&adalToken), nil
+}
+
+// GetSettingsFromFile returns the available authentication settings from an Azure CLI authentication file.
+func GetSettingsFromFile() (FileSettings, error) {
+ s := FileSettings{}
+ fileLocation := os.Getenv("AZURE_AUTH_LOCATION")
+ if fileLocation == "" {
+ return s, errors.New("environment variable AZURE_AUTH_LOCATION is not set")
+ }
+
+ contents, err := ioutil.ReadFile(fileLocation)
+ if err != nil {
+ return s, err
+ }
+
+ // Auth file might be encoded
+ decoded, err := decode(contents)
+ if err != nil {
+ return s, err
+ }
+
+ authFile := map[string]interface{}{}
+ err = json.Unmarshal(decoded, &authFile)
+ if err != nil {
+ return s, err
+ }
+
+ s.Values = map[string]string{}
+ s.setKeyValue(ClientID, authFile["clientId"])
+ s.setKeyValue(ClientSecret, authFile["clientSecret"])
+ s.setKeyValue(CertificatePath, authFile["clientCertificate"])
+ s.setKeyValue(CertificatePassword, authFile["clientCertificatePassword"])
+ s.setKeyValue(SubscriptionID, authFile["subscriptionId"])
+ s.setKeyValue(TenantID, authFile["tenantId"])
+ s.setKeyValue(ActiveDirectoryEndpoint, authFile["activeDirectoryEndpointUrl"])
+ s.setKeyValue(ResourceManagerEndpoint, authFile["resourceManagerEndpointUrl"])
+ s.setKeyValue(GraphResourceID, authFile["activeDirectoryGraphResourceId"])
+ s.setKeyValue(SQLManagementEndpoint, authFile["sqlManagementEndpointUrl"])
+ s.setKeyValue(GalleryEndpoint, authFile["galleryEndpointUrl"])
+ s.setKeyValue(ManagementEndpoint, authFile["managementEndpointUrl"])
+ return s, nil
+}
+
+// FileSettings contains the available authentication settings.
+type FileSettings struct {
+ Values map[string]string
+}
+
+// GetSubscriptionID returns the available subscription ID or an empty string.
+func (settings FileSettings) GetSubscriptionID() string {
+ return settings.Values[SubscriptionID]
+}
+
+// adds the specified value to the Values map if it isn't nil
+func (settings FileSettings) setKeyValue(key string, val interface{}) {
+ if val != nil {
+ settings.Values[key] = val.(string)
+ }
+}
+
+// returns the specified AAD endpoint or the public cloud endpoint if unspecified
+func (settings FileSettings) getAADEndpoint() string {
+ if v, ok := settings.Values[ActiveDirectoryEndpoint]; ok {
+ return v
+ }
+ return azure.PublicCloud.ActiveDirectoryEndpoint
+}
+
+// ClientCredentialsAuthorizer creates an authorizer from the available client credentials.
+func (settings FileSettings) ClientCredentialsAuthorizer(baseURI string) (autorest.Authorizer, error) {
+ resource, err := settings.getResourceForToken(baseURI)
+ if err != nil {
+ return nil, err
+ }
+ return settings.ClientCredentialsAuthorizerWithResource(resource)
+}
+
+// ClientCredentialsAuthorizerWithResource creates an authorizer from the available client credentials and the specified resource.
+func (settings FileSettings) ClientCredentialsAuthorizerWithResource(resource string) (autorest.Authorizer, error) {
+ if _, ok := settings.Values[ClientSecret]; !ok {
+ return nil, errors.New("missing client secret")
+ }
+ config, err := adal.NewOAuthConfig(settings.getAADEndpoint(), settings.Values[TenantID])
+ if err != nil {
+ return nil, err
+ }
+
+ spToken, err := adal.NewServicePrincipalToken(*config, settings.Values[ClientID], settings.Values[ClientSecret], resource)
+ if err != nil {
+ return nil, err
+ }
+
+ return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// ClientCertificateAuthorizer creates an authorizer from the available certificate credentials.
+func (settings FileSettings) ClientCertificateAuthorizer(baseURI string) (autorest.Authorizer, error) {
+ resource, err := settings.getResourceForToken(baseURI)
+ if err != nil {
+ return nil, err
+ }
+ return settings.ClientCertificateAuthorizerWithResource(resource)
+}
+
+// ClientCertificateAuthorizerWithResource creates an authorizer from the available certificate credentials and the specified resource.
+func (settings FileSettings) ClientCertificateAuthorizerWithResource(resource string) (autorest.Authorizer, error) {
+ if _, ok := settings.Values[CertificatePath]; !ok {
+ return nil, errors.New("missing certificate path")
+ }
+ cfg := NewClientCertificateConfig(settings.Values[CertificatePath], settings.Values[CertificatePassword], settings.Values[ClientID], settings.Values[TenantID])
+ cfg.AADEndpoint = settings.getAADEndpoint()
+ cfg.Resource = resource
+ return cfg.Authorizer()
+}
+
+func decode(b []byte) ([]byte, error) {
+ reader, enc := utfbom.Skip(bytes.NewReader(b))
+
+ switch enc {
+ case utfbom.UTF16LittleEndian:
+ u16 := make([]uint16, (len(b)/2)-1)
+ err := binary.Read(reader, binary.LittleEndian, &u16)
+ if err != nil {
+ return nil, err
+ }
+ return []byte(string(utf16.Decode(u16))), nil
+ case utfbom.UTF16BigEndian:
+ u16 := make([]uint16, (len(b)/2)-1)
+ err := binary.Read(reader, binary.BigEndian, &u16)
+ if err != nil {
+ return nil, err
+ }
+ return []byte(string(utf16.Decode(u16))), nil
+ }
+ return ioutil.ReadAll(reader)
+}
+
+func (settings FileSettings) getResourceForToken(baseURI string) (string, error) {
+ // Compare dafault base URI from the SDK to the endpoints from the public cloud
+ // Base URI and token resource are the same string. This func finds the authentication
+ // file field that matches the SDK base URI. The SDK defines the public cloud
+ // endpoint as its default base URI
+ if !strings.HasSuffix(baseURI, "/") {
+ baseURI += "/"
+ }
+ switch baseURI {
+ case azure.PublicCloud.ServiceManagementEndpoint:
+ return settings.Values[ManagementEndpoint], nil
+ case azure.PublicCloud.ResourceManagerEndpoint:
+ return settings.Values[ResourceManagerEndpoint], nil
+ case azure.PublicCloud.ActiveDirectoryEndpoint:
+ return settings.Values[ActiveDirectoryEndpoint], nil
+ case azure.PublicCloud.GalleryEndpoint:
+ return settings.Values[GalleryEndpoint], nil
+ case azure.PublicCloud.GraphEndpoint:
+ return settings.Values[GraphResourceID], nil
+ }
+ return "", fmt.Errorf("auth: base URI not found in endpoints")
+}
+
+// NewClientCredentialsConfig creates an AuthorizerConfig object configured to obtain an Authorizer through Client Credentials.
+// Defaults to Public Cloud and Resource Manager Endpoint.
+func NewClientCredentialsConfig(clientID string, clientSecret string, tenantID string) ClientCredentialsConfig {
+ return ClientCredentialsConfig{
+ ClientID: clientID,
+ ClientSecret: clientSecret,
+ TenantID: tenantID,
+ Resource: azure.PublicCloud.ResourceManagerEndpoint,
+ AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
+ }
+}
+
+// NewClientCertificateConfig creates a ClientCertificateConfig object configured to obtain an Authorizer through client certificate.
+// Defaults to Public Cloud and Resource Manager Endpoint.
+func NewClientCertificateConfig(certificatePath string, certificatePassword string, clientID string, tenantID string) ClientCertificateConfig {
+ return ClientCertificateConfig{
+ CertificatePath: certificatePath,
+ CertificatePassword: certificatePassword,
+ ClientID: clientID,
+ TenantID: tenantID,
+ Resource: azure.PublicCloud.ResourceManagerEndpoint,
+ AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
+ }
+}
+
+// NewUsernamePasswordConfig creates an UsernamePasswordConfig object configured to obtain an Authorizer through username and password.
+// Defaults to Public Cloud and Resource Manager Endpoint.
+func NewUsernamePasswordConfig(username string, password string, clientID string, tenantID string) UsernamePasswordConfig {
+ return UsernamePasswordConfig{
+ Username: username,
+ Password: password,
+ ClientID: clientID,
+ TenantID: tenantID,
+ Resource: azure.PublicCloud.ResourceManagerEndpoint,
+ AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
+ }
+}
+
+// NewMSIConfig creates an MSIConfig object configured to obtain an Authorizer through MSI.
+func NewMSIConfig() MSIConfig {
+ return MSIConfig{
+ Resource: azure.PublicCloud.ResourceManagerEndpoint,
+ }
+}
+
+// NewDeviceFlowConfig creates a DeviceFlowConfig object configured to obtain an Authorizer through device flow.
+// Defaults to Public Cloud and Resource Manager Endpoint.
+func NewDeviceFlowConfig(clientID string, tenantID string) DeviceFlowConfig {
+ return DeviceFlowConfig{
+ ClientID: clientID,
+ TenantID: tenantID,
+ Resource: azure.PublicCloud.ResourceManagerEndpoint,
+ AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
+ }
+}
+
+//AuthorizerConfig provides an authorizer from the configuration provided.
+type AuthorizerConfig interface {
+ Authorizer() (autorest.Authorizer, error)
+}
+
+// ClientCredentialsConfig provides the options to get a bearer authorizer from client credentials.
+type ClientCredentialsConfig struct {
+ ClientID string
+ ClientSecret string
+ TenantID string
+ AADEndpoint string
+ Resource string
+}
+
+// Authorizer gets the authorizer from client credentials.
+func (ccc ClientCredentialsConfig) Authorizer() (autorest.Authorizer, error) {
+ oauthConfig, err := adal.NewOAuthConfig(ccc.AADEndpoint, ccc.TenantID)
+ if err != nil {
+ return nil, err
+ }
+
+ spToken, err := adal.NewServicePrincipalToken(*oauthConfig, ccc.ClientID, ccc.ClientSecret, ccc.Resource)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get oauth token from client credentials: %v", err)
+ }
+
+ return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// ClientCertificateConfig provides the options to get a bearer authorizer from a client certificate.
+type ClientCertificateConfig struct {
+ ClientID string
+ CertificatePath string
+ CertificatePassword string
+ TenantID string
+ AADEndpoint string
+ Resource string
+}
+
+// Authorizer gets an authorizer object from client certificate.
+func (ccc ClientCertificateConfig) Authorizer() (autorest.Authorizer, error) {
+ oauthConfig, err := adal.NewOAuthConfig(ccc.AADEndpoint, ccc.TenantID)
+
+ certData, err := ioutil.ReadFile(ccc.CertificatePath)
+ if err != nil {
+ return nil, fmt.Errorf("failed to read the certificate file (%s): %v", ccc.CertificatePath, err)
+ }
+
+ certificate, rsaPrivateKey, err := decodePkcs12(certData, ccc.CertificatePassword)
+ if err != nil {
+ return nil, fmt.Errorf("failed to decode pkcs12 certificate while creating spt: %v", err)
+ }
+
+ spToken, err := adal.NewServicePrincipalTokenFromCertificate(*oauthConfig, ccc.ClientID, certificate, rsaPrivateKey, ccc.Resource)
+
+ if err != nil {
+ return nil, fmt.Errorf("failed to get oauth token from certificate auth: %v", err)
+ }
+
+ return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// DeviceFlowConfig provides the options to get a bearer authorizer using device flow authentication.
+type DeviceFlowConfig struct {
+ ClientID string
+ TenantID string
+ AADEndpoint string
+ Resource string
+}
+
+// Authorizer gets the authorizer from device flow.
+func (dfc DeviceFlowConfig) Authorizer() (autorest.Authorizer, error) {
+ spToken, err := dfc.ServicePrincipalToken()
+ if err != nil {
+ return nil, fmt.Errorf("failed to get oauth token from device flow: %v", err)
+ }
+
+ return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// ServicePrincipalToken gets the service principal token from device flow.
+func (dfc DeviceFlowConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
+ oauthClient := &autorest.Client{}
+ oauthConfig, err := adal.NewOAuthConfig(dfc.AADEndpoint, dfc.TenantID)
+ deviceCode, err := adal.InitiateDeviceAuth(oauthClient, *oauthConfig, dfc.ClientID, dfc.Resource)
+ if err != nil {
+ return nil, fmt.Errorf("failed to start device auth flow: %s", err)
+ }
+
+ log.Println(*deviceCode.Message)
+
+ token, err := adal.WaitForUserCompletion(oauthClient, deviceCode)
+ if err != nil {
+ return nil, fmt.Errorf("failed to finish device auth flow: %s", err)
+ }
+
+ return adal.NewServicePrincipalTokenFromManualToken(*oauthConfig, dfc.ClientID, dfc.Resource, *token)
+}
+
+func decodePkcs12(pkcs []byte, password string) (*x509.Certificate, *rsa.PrivateKey, error) {
+ privateKey, certificate, err := pkcs12.Decode(pkcs, password)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ rsaPrivateKey, isRsaKey := privateKey.(*rsa.PrivateKey)
+ if !isRsaKey {
+ return nil, nil, fmt.Errorf("PKCS#12 certificate must contain an RSA private key")
+ }
+
+ return certificate, rsaPrivateKey, nil
+}
+
+// UsernamePasswordConfig provides the options to get a bearer authorizer from a username and a password.
+type UsernamePasswordConfig struct {
+ ClientID string
+ Username string
+ Password string
+ TenantID string
+ AADEndpoint string
+ Resource string
+}
+
+// Authorizer gets the authorizer from a username and a password.
+func (ups UsernamePasswordConfig) Authorizer() (autorest.Authorizer, error) {
+
+ oauthConfig, err := adal.NewOAuthConfig(ups.AADEndpoint, ups.TenantID)
+
+ spToken, err := adal.NewServicePrincipalTokenFromUsernamePassword(*oauthConfig, ups.ClientID, ups.Username, ups.Password, ups.Resource)
+
+ if err != nil {
+ return nil, fmt.Errorf("failed to get oauth token from username and password auth: %v", err)
+ }
+
+ return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// MSIConfig provides the options to get a bearer authorizer through MSI.
+type MSIConfig struct {
+ Resource string
+ ClientID string
+}
+
+// Authorizer gets the authorizer from MSI.
+func (mc MSIConfig) Authorizer() (autorest.Authorizer, error) {
+ msiEndpoint, err := adal.GetMSIVMEndpoint()
+ if err != nil {
+ return nil, err
+ }
+
+ var spToken *adal.ServicePrincipalToken
+ if mc.ClientID == "" {
+ spToken, err = adal.NewServicePrincipalTokenFromMSI(msiEndpoint, mc.Resource)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get oauth token from MSI: %v", err)
+ }
+ } else {
+ spToken, err = adal.NewServicePrincipalTokenFromMSIWithUserAssignedID(msiEndpoint, mc.Resource, mc.ClientID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get oauth token from MSI for user assigned identity: %v", err)
+ }
+ }
+
+ return autorest.NewBearerAuthorizer(spToken), nil
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/azure.go b/vendor/github.com/Azure/go-autorest/autorest/azure/azure.go
new file mode 100644
index 0000000000..3a0a439ff9
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/azure.go
@@ -0,0 +1,326 @@
+// Package azure provides Azure-specific implementations used with AutoRest.
+// See the included examples for more detail.
+package azure
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "regexp"
+ "strconv"
+ "strings"
+
+ "github.com/Azure/go-autorest/autorest"
+)
+
+const (
+ // HeaderClientID is the Azure extension header to set a user-specified request ID.
+ HeaderClientID = "x-ms-client-request-id"
+
+ // HeaderReturnClientID is the Azure extension header to set if the user-specified request ID
+ // should be included in the response.
+ HeaderReturnClientID = "x-ms-return-client-request-id"
+
+ // HeaderRequestID is the Azure extension header of the service generated request ID returned
+ // in the response.
+ HeaderRequestID = "x-ms-request-id"
+)
+
+// ServiceError encapsulates the error response from an Azure service.
+// It adhears to the OData v4 specification for error responses.
+type ServiceError struct {
+ Code string `json:"code"`
+ Message string `json:"message"`
+ Target *string `json:"target"`
+ Details []map[string]interface{} `json:"details"`
+ InnerError map[string]interface{} `json:"innererror"`
+ AdditionalInfo []map[string]interface{} `json:"additionalInfo"`
+}
+
+func (se ServiceError) Error() string {
+ result := fmt.Sprintf("Code=%q Message=%q", se.Code, se.Message)
+
+ if se.Target != nil {
+ result += fmt.Sprintf(" Target=%q", *se.Target)
+ }
+
+ if se.Details != nil {
+ d, err := json.Marshal(se.Details)
+ if err != nil {
+ result += fmt.Sprintf(" Details=%v", se.Details)
+ }
+ result += fmt.Sprintf(" Details=%v", string(d))
+ }
+
+ if se.InnerError != nil {
+ d, err := json.Marshal(se.InnerError)
+ if err != nil {
+ result += fmt.Sprintf(" InnerError=%v", se.InnerError)
+ }
+ result += fmt.Sprintf(" InnerError=%v", string(d))
+ }
+
+ if se.AdditionalInfo != nil {
+ d, err := json.Marshal(se.AdditionalInfo)
+ if err != nil {
+ result += fmt.Sprintf(" AdditionalInfo=%v", se.AdditionalInfo)
+ }
+ result += fmt.Sprintf(" AdditionalInfo=%v", string(d))
+ }
+
+ return result
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface for the ServiceError type.
+func (se *ServiceError) UnmarshalJSON(b []byte) error {
+ // per the OData v4 spec the details field must be an array of JSON objects.
+ // unfortunately not all services adhear to the spec and just return a single
+ // object instead of an array with one object. so we have to perform some
+ // shenanigans to accommodate both cases.
+ // http://docs.oasis-open.org/odata/odata-json-format/v4.0/os/odata-json-format-v4.0-os.html#_Toc372793091
+
+ type serviceError1 struct {
+ Code string `json:"code"`
+ Message string `json:"message"`
+ Target *string `json:"target"`
+ Details []map[string]interface{} `json:"details"`
+ InnerError map[string]interface{} `json:"innererror"`
+ AdditionalInfo []map[string]interface{} `json:"additionalInfo"`
+ }
+
+ type serviceError2 struct {
+ Code string `json:"code"`
+ Message string `json:"message"`
+ Target *string `json:"target"`
+ Details map[string]interface{} `json:"details"`
+ InnerError map[string]interface{} `json:"innererror"`
+ AdditionalInfo []map[string]interface{} `json:"additionalInfo"`
+ }
+
+ se1 := serviceError1{}
+ err := json.Unmarshal(b, &se1)
+ if err == nil {
+ se.populate(se1.Code, se1.Message, se1.Target, se1.Details, se1.InnerError, se1.AdditionalInfo)
+ return nil
+ }
+
+ se2 := serviceError2{}
+ err = json.Unmarshal(b, &se2)
+ if err == nil {
+ se.populate(se2.Code, se2.Message, se2.Target, nil, se2.InnerError, se2.AdditionalInfo)
+ se.Details = append(se.Details, se2.Details)
+ return nil
+ }
+ return err
+}
+
+func (se *ServiceError) populate(code, message string, target *string, details []map[string]interface{}, inner map[string]interface{}, additional []map[string]interface{}) {
+ se.Code = code
+ se.Message = message
+ se.Target = target
+ se.Details = details
+ se.InnerError = inner
+ se.AdditionalInfo = additional
+}
+
+// RequestError describes an error response returned by Azure service.
+type RequestError struct {
+ autorest.DetailedError
+
+ // The error returned by the Azure service.
+ ServiceError *ServiceError `json:"error"`
+
+ // The request id (from the x-ms-request-id-header) of the request.
+ RequestID string
+}
+
+// Error returns a human-friendly error message from service error.
+func (e RequestError) Error() string {
+ return fmt.Sprintf("autorest/azure: Service returned an error. Status=%v %v",
+ e.StatusCode, e.ServiceError)
+}
+
+// IsAzureError returns true if the passed error is an Azure Service error; false otherwise.
+func IsAzureError(e error) bool {
+ _, ok := e.(*RequestError)
+ return ok
+}
+
+// Resource contains details about an Azure resource.
+type Resource struct {
+ SubscriptionID string
+ ResourceGroup string
+ Provider string
+ ResourceType string
+ ResourceName string
+}
+
+// ParseResourceID parses a resource ID into a ResourceDetails struct.
+// See https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-group-template-functions-resource#return-value-4.
+func ParseResourceID(resourceID string) (Resource, error) {
+
+ const resourceIDPatternText = `(?i)subscriptions/(.+)/resourceGroups/(.+)/providers/(.+?)/(.+?)/(.+)`
+ resourceIDPattern := regexp.MustCompile(resourceIDPatternText)
+ match := resourceIDPattern.FindStringSubmatch(resourceID)
+
+ if len(match) == 0 {
+ return Resource{}, fmt.Errorf("parsing failed for %s. Invalid resource Id format", resourceID)
+ }
+
+ v := strings.Split(match[5], "/")
+ resourceName := v[len(v)-1]
+
+ result := Resource{
+ SubscriptionID: match[1],
+ ResourceGroup: match[2],
+ Provider: match[3],
+ ResourceType: match[4],
+ ResourceName: resourceName,
+ }
+
+ return result, nil
+}
+
+// NewErrorWithError creates a new Error conforming object from the
+// passed packageType, method, statusCode of the given resp (UndefinedStatusCode
+// if resp is nil), message, and original error. message is treated as a format
+// string to which the optional args apply.
+func NewErrorWithError(original error, packageType string, method string, resp *http.Response, message string, args ...interface{}) RequestError {
+ if v, ok := original.(*RequestError); ok {
+ return *v
+ }
+
+ statusCode := autorest.UndefinedStatusCode
+ if resp != nil {
+ statusCode = resp.StatusCode
+ }
+ return RequestError{
+ DetailedError: autorest.DetailedError{
+ Original: original,
+ PackageType: packageType,
+ Method: method,
+ StatusCode: statusCode,
+ Message: fmt.Sprintf(message, args...),
+ },
+ }
+}
+
+// WithReturningClientID returns a PrepareDecorator that adds an HTTP extension header of
+// x-ms-client-request-id whose value is the passed, undecorated UUID (e.g.,
+// "0F39878C-5F76-4DB8-A25D-61D2C193C3CA"). It also sets the x-ms-return-client-request-id
+// header to true such that UUID accompanies the http.Response.
+func WithReturningClientID(uuid string) autorest.PrepareDecorator {
+ preparer := autorest.CreatePreparer(
+ WithClientID(uuid),
+ WithReturnClientID(true))
+
+ return func(p autorest.Preparer) autorest.Preparer {
+ return autorest.PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err != nil {
+ return r, err
+ }
+ return preparer.Prepare(r)
+ })
+ }
+}
+
+// WithClientID returns a PrepareDecorator that adds an HTTP extension header of
+// x-ms-client-request-id whose value is passed, undecorated UUID (e.g.,
+// "0F39878C-5F76-4DB8-A25D-61D2C193C3CA").
+func WithClientID(uuid string) autorest.PrepareDecorator {
+ return autorest.WithHeader(HeaderClientID, uuid)
+}
+
+// WithReturnClientID returns a PrepareDecorator that adds an HTTP extension header of
+// x-ms-return-client-request-id whose boolean value indicates if the value of the
+// x-ms-client-request-id header should be included in the http.Response.
+func WithReturnClientID(b bool) autorest.PrepareDecorator {
+ return autorest.WithHeader(HeaderReturnClientID, strconv.FormatBool(b))
+}
+
+// ExtractClientID extracts the client identifier from the x-ms-client-request-id header set on the
+// http.Request sent to the service (and returned in the http.Response)
+func ExtractClientID(resp *http.Response) string {
+ return autorest.ExtractHeaderValue(HeaderClientID, resp)
+}
+
+// ExtractRequestID extracts the Azure server generated request identifier from the
+// x-ms-request-id header.
+func ExtractRequestID(resp *http.Response) string {
+ return autorest.ExtractHeaderValue(HeaderRequestID, resp)
+}
+
+// WithErrorUnlessStatusCode returns a RespondDecorator that emits an
+// azure.RequestError by reading the response body unless the response HTTP status code
+// is among the set passed.
+//
+// If there is a chance service may return responses other than the Azure error
+// format and the response cannot be parsed into an error, a decoding error will
+// be returned containing the response body. In any case, the Responder will
+// return an error if the status code is not satisfied.
+//
+// If this Responder returns an error, the response body will be replaced with
+// an in-memory reader, which needs no further closing.
+func WithErrorUnlessStatusCode(codes ...int) autorest.RespondDecorator {
+ return func(r autorest.Responder) autorest.Responder {
+ return autorest.ResponderFunc(func(resp *http.Response) error {
+ err := r.Respond(resp)
+ if err == nil && !autorest.ResponseHasStatusCode(resp, codes...) {
+ var e RequestError
+ defer resp.Body.Close()
+
+ // Copy and replace the Body in case it does not contain an error object.
+ // This will leave the Body available to the caller.
+ b, decodeErr := autorest.CopyAndDecode(autorest.EncodedAsJSON, resp.Body, &e)
+ resp.Body = ioutil.NopCloser(&b)
+ if decodeErr != nil {
+ return fmt.Errorf("autorest/azure: error response cannot be parsed: %q error: %v", b.String(), decodeErr)
+ }
+ if e.ServiceError == nil {
+ // Check if error is unwrapped ServiceError
+ if err := json.Unmarshal(b.Bytes(), &e.ServiceError); err != nil {
+ return err
+ }
+ }
+ if e.ServiceError.Message == "" {
+ // if we're here it means the returned error wasn't OData v4 compliant.
+ // try to unmarshal the body as raw JSON in hopes of getting something.
+ rawBody := map[string]interface{}{}
+ if err := json.Unmarshal(b.Bytes(), &rawBody); err != nil {
+ return err
+ }
+ e.ServiceError = &ServiceError{
+ Code: "Unknown",
+ Message: "Unknown service error",
+ }
+ if len(rawBody) > 0 {
+ e.ServiceError.Details = []map[string]interface{}{rawBody}
+ }
+ }
+ e.Response = resp
+ e.RequestID = ExtractRequestID(resp)
+ if e.StatusCode == nil {
+ e.StatusCode = resp.StatusCode
+ }
+ err = &e
+ }
+ return err
+ })
+ }
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go
new file mode 100644
index 0000000000..a336b958d4
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go
@@ -0,0 +1,79 @@
+package cli
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+
+ "github.com/dimchansky/utfbom"
+ "github.com/mitchellh/go-homedir"
+)
+
+// Profile represents a Profile from the Azure CLI
+type Profile struct {
+ InstallationID string `json:"installationId"`
+ Subscriptions []Subscription `json:"subscriptions"`
+}
+
+// Subscription represents a Subscription from the Azure CLI
+type Subscription struct {
+ EnvironmentName string `json:"environmentName"`
+ ID string `json:"id"`
+ IsDefault bool `json:"isDefault"`
+ Name string `json:"name"`
+ State string `json:"state"`
+ TenantID string `json:"tenantId"`
+ User *User `json:"user"`
+}
+
+// User represents a User from the Azure CLI
+type User struct {
+ Name string `json:"name"`
+ Type string `json:"type"`
+}
+
+const azureProfileJSON = "azureProfile.json"
+
+// ProfilePath returns the path where the Azure Profile is stored from the Azure CLI
+func ProfilePath() (string, error) {
+ if cfgDir := os.Getenv("AZURE_CONFIG_DIR"); cfgDir != "" {
+ return filepath.Join(cfgDir, azureProfileJSON), nil
+ }
+ return homedir.Expand("~/.azure/" + azureProfileJSON)
+}
+
+// LoadProfile restores a Profile object from a file located at 'path'.
+func LoadProfile(path string) (result Profile, err error) {
+ var contents []byte
+ contents, err = ioutil.ReadFile(path)
+ if err != nil {
+ err = fmt.Errorf("failed to open file (%s) while loading token: %v", path, err)
+ return
+ }
+ reader := utfbom.SkipOnly(bytes.NewReader(contents))
+
+ dec := json.NewDecoder(reader)
+ if err = dec.Decode(&result); err != nil {
+ err = fmt.Errorf("failed to decode contents of file (%s) into a Profile representation: %v", path, err)
+ return
+ }
+
+ return
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go
new file mode 100644
index 0000000000..dece9ec631
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go
@@ -0,0 +1,170 @@
+package cli
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "os"
+ "os/exec"
+ "regexp"
+ "runtime"
+ "strconv"
+ "time"
+
+ "github.com/Azure/go-autorest/autorest/adal"
+ "github.com/Azure/go-autorest/autorest/date"
+ "github.com/mitchellh/go-homedir"
+)
+
+// Token represents an AccessToken from the Azure CLI
+type Token struct {
+ AccessToken string `json:"accessToken"`
+ Authority string `json:"_authority"`
+ ClientID string `json:"_clientId"`
+ ExpiresOn string `json:"expiresOn"`
+ IdentityProvider string `json:"identityProvider"`
+ IsMRRT bool `json:"isMRRT"`
+ RefreshToken string `json:"refreshToken"`
+ Resource string `json:"resource"`
+ TokenType string `json:"tokenType"`
+ UserID string `json:"userId"`
+}
+
+// ToADALToken converts an Azure CLI `Token`` to an `adal.Token``
+func (t Token) ToADALToken() (converted adal.Token, err error) {
+ tokenExpirationDate, err := ParseExpirationDate(t.ExpiresOn)
+ if err != nil {
+ err = fmt.Errorf("Error parsing Token Expiration Date %q: %+v", t.ExpiresOn, err)
+ return
+ }
+
+ difference := tokenExpirationDate.Sub(date.UnixEpoch())
+
+ converted = adal.Token{
+ AccessToken: t.AccessToken,
+ Type: t.TokenType,
+ ExpiresIn: "3600",
+ ExpiresOn: json.Number(strconv.Itoa(int(difference.Seconds()))),
+ RefreshToken: t.RefreshToken,
+ Resource: t.Resource,
+ }
+ return
+}
+
+// AccessTokensPath returns the path where access tokens are stored from the Azure CLI
+// TODO(#199): add unit test.
+func AccessTokensPath() (string, error) {
+ // Azure-CLI allows user to customize the path of access tokens thorugh environment variable.
+ var accessTokenPath = os.Getenv("AZURE_ACCESS_TOKEN_FILE")
+ var err error
+
+ // Fallback logic to default path on non-cloud-shell environment.
+ // TODO(#200): remove the dependency on hard-coding path.
+ if accessTokenPath == "" {
+ accessTokenPath, err = homedir.Expand("~/.azure/accessTokens.json")
+ }
+
+ return accessTokenPath, err
+}
+
+// ParseExpirationDate parses either a Azure CLI or CloudShell date into a time object
+func ParseExpirationDate(input string) (*time.Time, error) {
+ // CloudShell (and potentially the Azure CLI in future)
+ expirationDate, cloudShellErr := time.Parse(time.RFC3339, input)
+ if cloudShellErr != nil {
+ // Azure CLI (Python) e.g. 2017-08-31 19:48:57.998857 (plus the local timezone)
+ const cliFormat = "2006-01-02 15:04:05.999999"
+ expirationDate, cliErr := time.ParseInLocation(cliFormat, input, time.Local)
+ if cliErr == nil {
+ return &expirationDate, nil
+ }
+
+ return nil, fmt.Errorf("Error parsing expiration date %q.\n\nCloudShell Error: \n%+v\n\nCLI Error:\n%+v", input, cloudShellErr, cliErr)
+ }
+
+ return &expirationDate, nil
+}
+
+// LoadTokens restores a set of Token objects from a file located at 'path'.
+func LoadTokens(path string) ([]Token, error) {
+ file, err := os.Open(path)
+ if err != nil {
+ return nil, fmt.Errorf("failed to open file (%s) while loading token: %v", path, err)
+ }
+ defer file.Close()
+
+ var tokens []Token
+
+ dec := json.NewDecoder(file)
+ if err = dec.Decode(&tokens); err != nil {
+ return nil, fmt.Errorf("failed to decode contents of file (%s) into a `cli.Token` representation: %v", path, err)
+ }
+
+ return tokens, nil
+}
+
+// GetTokenFromCLI gets a token using Azure CLI 2.0 for local development scenarios.
+func GetTokenFromCLI(resource string) (*Token, error) {
+ // This is the path that a developer can set to tell this class what the install path for Azure CLI is.
+ const azureCLIPath = "AzureCLIPath"
+
+ // The default install paths are used to find Azure CLI. This is for security, so that any path in the calling program's Path environment is not used to execute Azure CLI.
+ azureCLIDefaultPathWindows := fmt.Sprintf("%s\\Microsoft SDKs\\Azure\\CLI2\\wbin; %s\\Microsoft SDKs\\Azure\\CLI2\\wbin", os.Getenv("ProgramFiles(x86)"), os.Getenv("ProgramFiles"))
+
+ // Default path for non-Windows.
+ const azureCLIDefaultPath = "/usr/bin:/usr/local/bin"
+
+ // Validate resource, since it gets sent as a command line argument to Azure CLI
+ const invalidResourceErrorTemplate = "Resource %s is not in expected format. Only alphanumeric characters, [dot], [colon], [hyphen], and [forward slash] are allowed."
+ match, err := regexp.MatchString("^[0-9a-zA-Z-.:/]+$", resource)
+ if err != nil {
+ return nil, err
+ }
+ if !match {
+ return nil, fmt.Errorf(invalidResourceErrorTemplate, resource)
+ }
+
+ // Execute Azure CLI to get token
+ var cliCmd *exec.Cmd
+ if runtime.GOOS == "windows" {
+ cliCmd = exec.Command(fmt.Sprintf("%s\\system32\\cmd.exe", os.Getenv("windir")))
+ cliCmd.Env = os.Environ()
+ cliCmd.Env = append(cliCmd.Env, fmt.Sprintf("PATH=%s;%s", os.Getenv(azureCLIPath), azureCLIDefaultPathWindows))
+ cliCmd.Args = append(cliCmd.Args, "/c")
+ } else {
+ cliCmd = exec.Command(os.Getenv("SHELL"))
+ cliCmd.Env = os.Environ()
+ cliCmd.Env = append(cliCmd.Env, fmt.Sprintf("PATH=%s:%s", os.Getenv(azureCLIPath), azureCLIDefaultPath))
+ }
+ cliCmd.Args = append(cliCmd.Args, "az", "account", "get-access-token", "-o", "json", "--resource", resource)
+
+ var stderr bytes.Buffer
+ cliCmd.Stderr = &stderr
+
+ output, err := cliCmd.Output()
+ if err != nil {
+ return nil, fmt.Errorf("Invoking Azure CLI failed with the following error: %s", stderr.String())
+ }
+
+ tokenResponse := Token{}
+ err = json.Unmarshal(output, &tokenResponse)
+ if err != nil {
+ return nil, err
+ }
+
+ return &tokenResponse, err
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go b/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go
new file mode 100644
index 0000000000..7e41f7fd99
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go
@@ -0,0 +1,191 @@
+package azure
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "strings"
+)
+
+// EnvironmentFilepathName captures the name of the environment variable containing the path to the file
+// to be used while populating the Azure Environment.
+const EnvironmentFilepathName = "AZURE_ENVIRONMENT_FILEPATH"
+
+var environments = map[string]Environment{
+ "AZURECHINACLOUD": ChinaCloud,
+ "AZUREGERMANCLOUD": GermanCloud,
+ "AZUREPUBLICCLOUD": PublicCloud,
+ "AZUREUSGOVERNMENTCLOUD": USGovernmentCloud,
+}
+
+// Environment represents a set of endpoints for each of Azure's Clouds.
+type Environment struct {
+ Name string `json:"name"`
+ ManagementPortalURL string `json:"managementPortalURL"`
+ PublishSettingsURL string `json:"publishSettingsURL"`
+ ServiceManagementEndpoint string `json:"serviceManagementEndpoint"`
+ ResourceManagerEndpoint string `json:"resourceManagerEndpoint"`
+ ActiveDirectoryEndpoint string `json:"activeDirectoryEndpoint"`
+ GalleryEndpoint string `json:"galleryEndpoint"`
+ KeyVaultEndpoint string `json:"keyVaultEndpoint"`
+ GraphEndpoint string `json:"graphEndpoint"`
+ ServiceBusEndpoint string `json:"serviceBusEndpoint"`
+ BatchManagementEndpoint string `json:"batchManagementEndpoint"`
+ StorageEndpointSuffix string `json:"storageEndpointSuffix"`
+ SQLDatabaseDNSSuffix string `json:"sqlDatabaseDNSSuffix"`
+ TrafficManagerDNSSuffix string `json:"trafficManagerDNSSuffix"`
+ KeyVaultDNSSuffix string `json:"keyVaultDNSSuffix"`
+ ServiceBusEndpointSuffix string `json:"serviceBusEndpointSuffix"`
+ ServiceManagementVMDNSSuffix string `json:"serviceManagementVMDNSSuffix"`
+ ResourceManagerVMDNSSuffix string `json:"resourceManagerVMDNSSuffix"`
+ ContainerRegistryDNSSuffix string `json:"containerRegistryDNSSuffix"`
+ TokenAudience string `json:"tokenAudience"`
+}
+
+var (
+ // PublicCloud is the default public Azure cloud environment
+ PublicCloud = Environment{
+ Name: "AzurePublicCloud",
+ ManagementPortalURL: "https://manage.windowsazure.com/",
+ PublishSettingsURL: "https://manage.windowsazure.com/publishsettings/index",
+ ServiceManagementEndpoint: "https://management.core.windows.net/",
+ ResourceManagerEndpoint: "https://management.azure.com/",
+ ActiveDirectoryEndpoint: "https://login.microsoftonline.com/",
+ GalleryEndpoint: "https://gallery.azure.com/",
+ KeyVaultEndpoint: "https://vault.azure.net/",
+ GraphEndpoint: "https://graph.windows.net/",
+ ServiceBusEndpoint: "https://servicebus.windows.net/",
+ BatchManagementEndpoint: "https://batch.core.windows.net/",
+ StorageEndpointSuffix: "core.windows.net",
+ SQLDatabaseDNSSuffix: "database.windows.net",
+ TrafficManagerDNSSuffix: "trafficmanager.net",
+ KeyVaultDNSSuffix: "vault.azure.net",
+ ServiceBusEndpointSuffix: "servicebus.windows.net",
+ ServiceManagementVMDNSSuffix: "cloudapp.net",
+ ResourceManagerVMDNSSuffix: "cloudapp.azure.com",
+ ContainerRegistryDNSSuffix: "azurecr.io",
+ TokenAudience: "https://management.azure.com/",
+ }
+
+ // USGovernmentCloud is the cloud environment for the US Government
+ USGovernmentCloud = Environment{
+ Name: "AzureUSGovernmentCloud",
+ ManagementPortalURL: "https://manage.windowsazure.us/",
+ PublishSettingsURL: "https://manage.windowsazure.us/publishsettings/index",
+ ServiceManagementEndpoint: "https://management.core.usgovcloudapi.net/",
+ ResourceManagerEndpoint: "https://management.usgovcloudapi.net/",
+ ActiveDirectoryEndpoint: "https://login.microsoftonline.us/",
+ GalleryEndpoint: "https://gallery.usgovcloudapi.net/",
+ KeyVaultEndpoint: "https://vault.usgovcloudapi.net/",
+ GraphEndpoint: "https://graph.windows.net/",
+ ServiceBusEndpoint: "https://servicebus.usgovcloudapi.net/",
+ BatchManagementEndpoint: "https://batch.core.usgovcloudapi.net/",
+ StorageEndpointSuffix: "core.usgovcloudapi.net",
+ SQLDatabaseDNSSuffix: "database.usgovcloudapi.net",
+ TrafficManagerDNSSuffix: "usgovtrafficmanager.net",
+ KeyVaultDNSSuffix: "vault.usgovcloudapi.net",
+ ServiceBusEndpointSuffix: "servicebus.usgovcloudapi.net",
+ ServiceManagementVMDNSSuffix: "usgovcloudapp.net",
+ ResourceManagerVMDNSSuffix: "cloudapp.windowsazure.us",
+ ContainerRegistryDNSSuffix: "azurecr.io",
+ TokenAudience: "https://management.usgovcloudapi.net/",
+ }
+
+ // ChinaCloud is the cloud environment operated in China
+ ChinaCloud = Environment{
+ Name: "AzureChinaCloud",
+ ManagementPortalURL: "https://manage.chinacloudapi.com/",
+ PublishSettingsURL: "https://manage.chinacloudapi.com/publishsettings/index",
+ ServiceManagementEndpoint: "https://management.core.chinacloudapi.cn/",
+ ResourceManagerEndpoint: "https://management.chinacloudapi.cn/",
+ ActiveDirectoryEndpoint: "https://login.chinacloudapi.cn/",
+ GalleryEndpoint: "https://gallery.chinacloudapi.cn/",
+ KeyVaultEndpoint: "https://vault.azure.cn/",
+ GraphEndpoint: "https://graph.chinacloudapi.cn/",
+ ServiceBusEndpoint: "https://servicebus.chinacloudapi.cn/",
+ BatchManagementEndpoint: "https://batch.chinacloudapi.cn/",
+ StorageEndpointSuffix: "core.chinacloudapi.cn",
+ SQLDatabaseDNSSuffix: "database.chinacloudapi.cn",
+ TrafficManagerDNSSuffix: "trafficmanager.cn",
+ KeyVaultDNSSuffix: "vault.azure.cn",
+ ServiceBusEndpointSuffix: "servicebus.chinacloudapi.cn",
+ ServiceManagementVMDNSSuffix: "chinacloudapp.cn",
+ ResourceManagerVMDNSSuffix: "cloudapp.azure.cn",
+ ContainerRegistryDNSSuffix: "azurecr.io",
+ TokenAudience: "https://management.chinacloudapi.cn/",
+ }
+
+ // GermanCloud is the cloud environment operated in Germany
+ GermanCloud = Environment{
+ Name: "AzureGermanCloud",
+ ManagementPortalURL: "http://portal.microsoftazure.de/",
+ PublishSettingsURL: "https://manage.microsoftazure.de/publishsettings/index",
+ ServiceManagementEndpoint: "https://management.core.cloudapi.de/",
+ ResourceManagerEndpoint: "https://management.microsoftazure.de/",
+ ActiveDirectoryEndpoint: "https://login.microsoftonline.de/",
+ GalleryEndpoint: "https://gallery.cloudapi.de/",
+ KeyVaultEndpoint: "https://vault.microsoftazure.de/",
+ GraphEndpoint: "https://graph.cloudapi.de/",
+ ServiceBusEndpoint: "https://servicebus.cloudapi.de/",
+ BatchManagementEndpoint: "https://batch.cloudapi.de/",
+ StorageEndpointSuffix: "core.cloudapi.de",
+ SQLDatabaseDNSSuffix: "database.cloudapi.de",
+ TrafficManagerDNSSuffix: "azuretrafficmanager.de",
+ KeyVaultDNSSuffix: "vault.microsoftazure.de",
+ ServiceBusEndpointSuffix: "servicebus.cloudapi.de",
+ ServiceManagementVMDNSSuffix: "azurecloudapp.de",
+ ResourceManagerVMDNSSuffix: "cloudapp.microsoftazure.de",
+ ContainerRegistryDNSSuffix: "azurecr.io",
+ TokenAudience: "https://management.microsoftazure.de/",
+ }
+)
+
+// EnvironmentFromName returns an Environment based on the common name specified.
+func EnvironmentFromName(name string) (Environment, error) {
+ // IMPORTANT
+ // As per @radhikagupta5:
+ // This is technical debt, fundamentally here because Kubernetes is not currently accepting
+ // contributions to the providers. Once that is an option, the provider should be updated to
+ // directly call `EnvironmentFromFile`. Until then, we rely on dispatching Azure Stack environment creation
+ // from this method based on the name that is provided to us.
+ if strings.EqualFold(name, "AZURESTACKCLOUD") {
+ return EnvironmentFromFile(os.Getenv(EnvironmentFilepathName))
+ }
+
+ name = strings.ToUpper(name)
+ env, ok := environments[name]
+ if !ok {
+ return env, fmt.Errorf("autorest/azure: There is no cloud environment matching the name %q", name)
+ }
+
+ return env, nil
+}
+
+// EnvironmentFromFile loads an Environment from a configuration file available on disk.
+// This function is particularly useful in the Hybrid Cloud model, where one must define their own
+// endpoints.
+func EnvironmentFromFile(location string) (unmarshaled Environment, err error) {
+ fileContents, err := ioutil.ReadFile(location)
+ if err != nil {
+ return
+ }
+
+ err = json.Unmarshal(fileContents, &unmarshaled)
+
+ return
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/metadata_environment.go b/vendor/github.com/Azure/go-autorest/autorest/azure/metadata_environment.go
new file mode 100644
index 0000000000..507f9e95cf
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/metadata_environment.go
@@ -0,0 +1,245 @@
+package azure
+
+import (
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "strings"
+
+ "github.com/Azure/go-autorest/autorest"
+)
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+type audience []string
+
+type authentication struct {
+ LoginEndpoint string `json:"loginEndpoint"`
+ Audiences audience `json:"audiences"`
+}
+
+type environmentMetadataInfo struct {
+ GalleryEndpoint string `json:"galleryEndpoint"`
+ GraphEndpoint string `json:"graphEndpoint"`
+ PortalEndpoint string `json:"portalEndpoint"`
+ Authentication authentication `json:"authentication"`
+}
+
+// EnvironmentProperty represent property names that clients can override
+type EnvironmentProperty string
+
+const (
+ // EnvironmentName ...
+ EnvironmentName EnvironmentProperty = "name"
+ // EnvironmentManagementPortalURL ..
+ EnvironmentManagementPortalURL EnvironmentProperty = "managementPortalURL"
+ // EnvironmentPublishSettingsURL ...
+ EnvironmentPublishSettingsURL EnvironmentProperty = "publishSettingsURL"
+ // EnvironmentServiceManagementEndpoint ...
+ EnvironmentServiceManagementEndpoint EnvironmentProperty = "serviceManagementEndpoint"
+ // EnvironmentResourceManagerEndpoint ...
+ EnvironmentResourceManagerEndpoint EnvironmentProperty = "resourceManagerEndpoint"
+ // EnvironmentActiveDirectoryEndpoint ...
+ EnvironmentActiveDirectoryEndpoint EnvironmentProperty = "activeDirectoryEndpoint"
+ // EnvironmentGalleryEndpoint ...
+ EnvironmentGalleryEndpoint EnvironmentProperty = "galleryEndpoint"
+ // EnvironmentKeyVaultEndpoint ...
+ EnvironmentKeyVaultEndpoint EnvironmentProperty = "keyVaultEndpoint"
+ // EnvironmentGraphEndpoint ...
+ EnvironmentGraphEndpoint EnvironmentProperty = "graphEndpoint"
+ // EnvironmentServiceBusEndpoint ...
+ EnvironmentServiceBusEndpoint EnvironmentProperty = "serviceBusEndpoint"
+ // EnvironmentBatchManagementEndpoint ...
+ EnvironmentBatchManagementEndpoint EnvironmentProperty = "batchManagementEndpoint"
+ // EnvironmentStorageEndpointSuffix ...
+ EnvironmentStorageEndpointSuffix EnvironmentProperty = "storageEndpointSuffix"
+ // EnvironmentSQLDatabaseDNSSuffix ...
+ EnvironmentSQLDatabaseDNSSuffix EnvironmentProperty = "sqlDatabaseDNSSuffix"
+ // EnvironmentTrafficManagerDNSSuffix ...
+ EnvironmentTrafficManagerDNSSuffix EnvironmentProperty = "trafficManagerDNSSuffix"
+ // EnvironmentKeyVaultDNSSuffix ...
+ EnvironmentKeyVaultDNSSuffix EnvironmentProperty = "keyVaultDNSSuffix"
+ // EnvironmentServiceBusEndpointSuffix ...
+ EnvironmentServiceBusEndpointSuffix EnvironmentProperty = "serviceBusEndpointSuffix"
+ // EnvironmentServiceManagementVMDNSSuffix ...
+ EnvironmentServiceManagementVMDNSSuffix EnvironmentProperty = "serviceManagementVMDNSSuffix"
+ // EnvironmentResourceManagerVMDNSSuffix ...
+ EnvironmentResourceManagerVMDNSSuffix EnvironmentProperty = "resourceManagerVMDNSSuffix"
+ // EnvironmentContainerRegistryDNSSuffix ...
+ EnvironmentContainerRegistryDNSSuffix EnvironmentProperty = "containerRegistryDNSSuffix"
+ // EnvironmentTokenAudience ...
+ EnvironmentTokenAudience EnvironmentProperty = "tokenAudience"
+)
+
+// OverrideProperty represents property name and value that clients can override
+type OverrideProperty struct {
+ Key EnvironmentProperty
+ Value string
+}
+
+// EnvironmentFromURL loads an Environment from a URL
+// This function is particularly useful in the Hybrid Cloud model, where one may define their own
+// endpoints.
+func EnvironmentFromURL(resourceManagerEndpoint string, properties ...OverrideProperty) (environment Environment, err error) {
+ var metadataEnvProperties environmentMetadataInfo
+
+ if resourceManagerEndpoint == "" {
+ return environment, fmt.Errorf("Metadata resource manager endpoint is empty")
+ }
+
+ if metadataEnvProperties, err = retrieveMetadataEnvironment(resourceManagerEndpoint); err != nil {
+ return environment, err
+ }
+
+ // Give priority to user's override values
+ overrideProperties(&environment, properties)
+
+ if environment.Name == "" {
+ environment.Name = "HybridEnvironment"
+ }
+ stampDNSSuffix := environment.StorageEndpointSuffix
+ if stampDNSSuffix == "" {
+ stampDNSSuffix = strings.TrimSuffix(strings.TrimPrefix(strings.Replace(resourceManagerEndpoint, strings.Split(resourceManagerEndpoint, ".")[0], "", 1), "."), "/")
+ environment.StorageEndpointSuffix = stampDNSSuffix
+ }
+ if environment.KeyVaultDNSSuffix == "" {
+ environment.KeyVaultDNSSuffix = fmt.Sprintf("%s.%s", "vault", stampDNSSuffix)
+ }
+ if environment.KeyVaultEndpoint == "" {
+ environment.KeyVaultEndpoint = fmt.Sprintf("%s%s", "https://", environment.KeyVaultDNSSuffix)
+ }
+ if environment.TokenAudience == "" {
+ environment.TokenAudience = metadataEnvProperties.Authentication.Audiences[0]
+ }
+ if environment.ActiveDirectoryEndpoint == "" {
+ environment.ActiveDirectoryEndpoint = metadataEnvProperties.Authentication.LoginEndpoint
+ }
+ if environment.ResourceManagerEndpoint == "" {
+ environment.ResourceManagerEndpoint = resourceManagerEndpoint
+ }
+ if environment.GalleryEndpoint == "" {
+ environment.GalleryEndpoint = metadataEnvProperties.GalleryEndpoint
+ }
+ if environment.GraphEndpoint == "" {
+ environment.GraphEndpoint = metadataEnvProperties.GraphEndpoint
+ }
+
+ return environment, nil
+}
+
+func overrideProperties(environment *Environment, properties []OverrideProperty) {
+ for _, property := range properties {
+ switch property.Key {
+ case EnvironmentName:
+ {
+ environment.Name = property.Value
+ }
+ case EnvironmentManagementPortalURL:
+ {
+ environment.ManagementPortalURL = property.Value
+ }
+ case EnvironmentPublishSettingsURL:
+ {
+ environment.PublishSettingsURL = property.Value
+ }
+ case EnvironmentServiceManagementEndpoint:
+ {
+ environment.ServiceManagementEndpoint = property.Value
+ }
+ case EnvironmentResourceManagerEndpoint:
+ {
+ environment.ResourceManagerEndpoint = property.Value
+ }
+ case EnvironmentActiveDirectoryEndpoint:
+ {
+ environment.ActiveDirectoryEndpoint = property.Value
+ }
+ case EnvironmentGalleryEndpoint:
+ {
+ environment.GalleryEndpoint = property.Value
+ }
+ case EnvironmentKeyVaultEndpoint:
+ {
+ environment.KeyVaultEndpoint = property.Value
+ }
+ case EnvironmentGraphEndpoint:
+ {
+ environment.GraphEndpoint = property.Value
+ }
+ case EnvironmentServiceBusEndpoint:
+ {
+ environment.ServiceBusEndpoint = property.Value
+ }
+ case EnvironmentBatchManagementEndpoint:
+ {
+ environment.BatchManagementEndpoint = property.Value
+ }
+ case EnvironmentStorageEndpointSuffix:
+ {
+ environment.StorageEndpointSuffix = property.Value
+ }
+ case EnvironmentSQLDatabaseDNSSuffix:
+ {
+ environment.SQLDatabaseDNSSuffix = property.Value
+ }
+ case EnvironmentTrafficManagerDNSSuffix:
+ {
+ environment.TrafficManagerDNSSuffix = property.Value
+ }
+ case EnvironmentKeyVaultDNSSuffix:
+ {
+ environment.KeyVaultDNSSuffix = property.Value
+ }
+ case EnvironmentServiceBusEndpointSuffix:
+ {
+ environment.ServiceBusEndpointSuffix = property.Value
+ }
+ case EnvironmentServiceManagementVMDNSSuffix:
+ {
+ environment.ServiceManagementVMDNSSuffix = property.Value
+ }
+ case EnvironmentResourceManagerVMDNSSuffix:
+ {
+ environment.ResourceManagerVMDNSSuffix = property.Value
+ }
+ case EnvironmentContainerRegistryDNSSuffix:
+ {
+ environment.ContainerRegistryDNSSuffix = property.Value
+ }
+ case EnvironmentTokenAudience:
+ {
+ environment.TokenAudience = property.Value
+ }
+ }
+ }
+}
+
+func retrieveMetadataEnvironment(endpoint string) (environment environmentMetadataInfo, err error) {
+ client := autorest.NewClientWithUserAgent("")
+ managementEndpoint := fmt.Sprintf("%s%s", strings.TrimSuffix(endpoint, "/"), "/metadata/endpoints?api-version=1.0")
+ req, _ := http.NewRequest("GET", managementEndpoint, nil)
+ response, err := client.Do(req)
+ if err != nil {
+ return environment, err
+ }
+ defer response.Body.Close()
+ jsonResponse, err := ioutil.ReadAll(response.Body)
+ if err != nil {
+ return environment, err
+ }
+ err = json.Unmarshal(jsonResponse, &environment)
+ return environment, err
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/rp.go b/vendor/github.com/Azure/go-autorest/autorest/azure/rp.go
new file mode 100644
index 0000000000..86ce9f2b5b
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/rp.go
@@ -0,0 +1,200 @@
+// Copyright 2017 Microsoft Corporation
+//
+// 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 azure
+
+import (
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+
+ "github.com/Azure/go-autorest/autorest"
+)
+
+// DoRetryWithRegistration tries to register the resource provider in case it is unregistered.
+// It also handles request retries
+func DoRetryWithRegistration(client autorest.Client) autorest.SendDecorator {
+ return func(s autorest.Sender) autorest.Sender {
+ return autorest.SenderFunc(func(r *http.Request) (resp *http.Response, err error) {
+ rr := autorest.NewRetriableRequest(r)
+ for currentAttempt := 0; currentAttempt < client.RetryAttempts; currentAttempt++ {
+ err = rr.Prepare()
+ if err != nil {
+ return resp, err
+ }
+
+ resp, err = autorest.SendWithSender(s, rr.Request(),
+ autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...),
+ )
+ if err != nil {
+ return resp, err
+ }
+
+ if resp.StatusCode != http.StatusConflict || client.SkipResourceProviderRegistration {
+ return resp, err
+ }
+ var re RequestError
+ err = autorest.Respond(
+ resp,
+ autorest.ByUnmarshallingJSON(&re),
+ )
+ if err != nil {
+ return resp, err
+ }
+ err = re
+
+ if re.ServiceError != nil && re.ServiceError.Code == "MissingSubscriptionRegistration" {
+ regErr := register(client, r, re)
+ if regErr != nil {
+ return resp, fmt.Errorf("failed auto registering Resource Provider: %s. Original error: %s", regErr, err)
+ }
+ }
+ }
+ return resp, err
+ })
+ }
+}
+
+func getProvider(re RequestError) (string, error) {
+ if re.ServiceError != nil && len(re.ServiceError.Details) > 0 {
+ return re.ServiceError.Details[0]["target"].(string), nil
+ }
+ return "", errors.New("provider was not found in the response")
+}
+
+func register(client autorest.Client, originalReq *http.Request, re RequestError) error {
+ subID := getSubscription(originalReq.URL.Path)
+ if subID == "" {
+ return errors.New("missing parameter subscriptionID to register resource provider")
+ }
+ providerName, err := getProvider(re)
+ if err != nil {
+ return fmt.Errorf("missing parameter provider to register resource provider: %s", err)
+ }
+ newURL := url.URL{
+ Scheme: originalReq.URL.Scheme,
+ Host: originalReq.URL.Host,
+ }
+
+ // taken from the resources SDK
+ // with almost identical code, this sections are easier to mantain
+ // It is also not a good idea to import the SDK here
+ // https://github.com/Azure/azure-sdk-for-go/blob/9f366792afa3e0ddaecdc860e793ba9d75e76c27/arm/resources/resources/providers.go#L252
+ pathParameters := map[string]interface{}{
+ "resourceProviderNamespace": autorest.Encode("path", providerName),
+ "subscriptionId": autorest.Encode("path", subID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(newURL.String()),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/{resourceProviderNamespace}/register", pathParameters),
+ autorest.WithQueryParameters(queryParameters),
+ )
+
+ req, err := preparer.Prepare(&http.Request{})
+ if err != nil {
+ return err
+ }
+ req = req.WithContext(originalReq.Context())
+
+ resp, err := autorest.SendWithSender(client, req,
+ autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...),
+ )
+ if err != nil {
+ return err
+ }
+
+ type Provider struct {
+ RegistrationState *string `json:"registrationState,omitempty"`
+ }
+ var provider Provider
+
+ err = autorest.Respond(
+ resp,
+ WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&provider),
+ autorest.ByClosing(),
+ )
+ if err != nil {
+ return err
+ }
+
+ // poll for registered provisioning state
+ registrationStartTime := time.Now()
+ for err == nil && (client.PollingDuration == 0 || (client.PollingDuration != 0 && time.Since(registrationStartTime) < client.PollingDuration)) {
+ // taken from the resources SDK
+ // https://github.com/Azure/azure-sdk-for-go/blob/9f366792afa3e0ddaecdc860e793ba9d75e76c27/arm/resources/resources/providers.go#L45
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(newURL.String()),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/{resourceProviderNamespace}", pathParameters),
+ autorest.WithQueryParameters(queryParameters),
+ )
+ req, err = preparer.Prepare(&http.Request{})
+ if err != nil {
+ return err
+ }
+ req = req.WithContext(originalReq.Context())
+
+ resp, err := autorest.SendWithSender(client, req,
+ autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...),
+ )
+ if err != nil {
+ return err
+ }
+
+ err = autorest.Respond(
+ resp,
+ WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&provider),
+ autorest.ByClosing(),
+ )
+ if err != nil {
+ return err
+ }
+
+ if provider.RegistrationState != nil &&
+ *provider.RegistrationState == "Registered" {
+ break
+ }
+
+ delayed := autorest.DelayWithRetryAfter(resp, originalReq.Context().Done())
+ if !delayed && !autorest.DelayForBackoff(client.PollingDelay, 0, originalReq.Context().Done()) {
+ return originalReq.Context().Err()
+ }
+ }
+ if client.PollingDuration != 0 && !(time.Since(registrationStartTime) < client.PollingDuration) {
+ return errors.New("polling for resource provider registration has exceeded the polling duration")
+ }
+ return err
+}
+
+func getSubscription(path string) string {
+ parts := strings.Split(path, "/")
+ for i, v := range parts {
+ if v == "subscriptions" && (i+1) < len(parts) {
+ return parts[i+1]
+ }
+ }
+ return ""
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/client.go b/vendor/github.com/Azure/go-autorest/autorest/client.go
new file mode 100644
index 0000000000..4874e6e82d
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/client.go
@@ -0,0 +1,270 @@
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "log"
+ "net/http"
+ "net/http/cookiejar"
+ "strings"
+ "time"
+
+ "github.com/Azure/go-autorest/logger"
+ "github.com/Azure/go-autorest/tracing"
+)
+
+const (
+ // DefaultPollingDelay is a reasonable delay between polling requests.
+ DefaultPollingDelay = 60 * time.Second
+
+ // DefaultPollingDuration is a reasonable total polling duration.
+ DefaultPollingDuration = 15 * time.Minute
+
+ // DefaultRetryAttempts is number of attempts for retry status codes (5xx).
+ DefaultRetryAttempts = 3
+
+ // DefaultRetryDuration is the duration to wait between retries.
+ DefaultRetryDuration = 30 * time.Second
+)
+
+var (
+ // StatusCodesForRetry are a defined group of status code for which the client will retry
+ StatusCodesForRetry = []int{
+ http.StatusRequestTimeout, // 408
+ http.StatusTooManyRequests, // 429
+ http.StatusInternalServerError, // 500
+ http.StatusBadGateway, // 502
+ http.StatusServiceUnavailable, // 503
+ http.StatusGatewayTimeout, // 504
+ }
+)
+
+const (
+ requestFormat = `HTTP Request Begin ===================================================
+%s
+===================================================== HTTP Request End
+`
+ responseFormat = `HTTP Response Begin ===================================================
+%s
+===================================================== HTTP Response End
+`
+)
+
+// Response serves as the base for all responses from generated clients. It provides access to the
+// last http.Response.
+type Response struct {
+ *http.Response `json:"-"`
+}
+
+// LoggingInspector implements request and response inspectors that log the full request and
+// response to a supplied log.
+type LoggingInspector struct {
+ Logger *log.Logger
+}
+
+// WithInspection returns a PrepareDecorator that emits the http.Request to the supplied logger. The
+// body is restored after being emitted.
+//
+// Note: Since it reads the entire Body, this decorator should not be used where body streaming is
+// important. It is best used to trace JSON or similar body values.
+func (li LoggingInspector) WithInspection() PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ var body, b bytes.Buffer
+
+ defer r.Body.Close()
+
+ r.Body = ioutil.NopCloser(io.TeeReader(r.Body, &body))
+ if err := r.Write(&b); err != nil {
+ return nil, fmt.Errorf("Failed to write response: %v", err)
+ }
+
+ li.Logger.Printf(requestFormat, b.String())
+
+ r.Body = ioutil.NopCloser(&body)
+ return p.Prepare(r)
+ })
+ }
+}
+
+// ByInspecting returns a RespondDecorator that emits the http.Response to the supplied logger. The
+// body is restored after being emitted.
+//
+// Note: Since it reads the entire Body, this decorator should not be used where body streaming is
+// important. It is best used to trace JSON or similar body values.
+func (li LoggingInspector) ByInspecting() RespondDecorator {
+ return func(r Responder) Responder {
+ return ResponderFunc(func(resp *http.Response) error {
+ var body, b bytes.Buffer
+ defer resp.Body.Close()
+ resp.Body = ioutil.NopCloser(io.TeeReader(resp.Body, &body))
+ if err := resp.Write(&b); err != nil {
+ return fmt.Errorf("Failed to write response: %v", err)
+ }
+
+ li.Logger.Printf(responseFormat, b.String())
+
+ resp.Body = ioutil.NopCloser(&body)
+ return r.Respond(resp)
+ })
+ }
+}
+
+// Client is the base for autorest generated clients. It provides default, "do nothing"
+// implementations of an Authorizer, RequestInspector, and ResponseInspector. It also returns the
+// standard, undecorated http.Client as a default Sender.
+//
+// Generated clients should also use Error (see NewError and NewErrorWithError) for errors and
+// return responses that compose with Response.
+//
+// Most customization of generated clients is best achieved by supplying a custom Authorizer, custom
+// RequestInspector, and / or custom ResponseInspector. Users may log requests, implement circuit
+// breakers (see https://msdn.microsoft.com/en-us/library/dn589784.aspx) or otherwise influence
+// sending the request by providing a decorated Sender.
+type Client struct {
+ Authorizer Authorizer
+ Sender Sender
+ RequestInspector PrepareDecorator
+ ResponseInspector RespondDecorator
+
+ // PollingDelay sets the polling frequency used in absence of a Retry-After HTTP header
+ PollingDelay time.Duration
+
+ // PollingDuration sets the maximum polling time after which an error is returned.
+ // Setting this to zero will use the provided context to control the duration.
+ PollingDuration time.Duration
+
+ // RetryAttempts sets the default number of retry attempts for client.
+ RetryAttempts int
+
+ // RetryDuration sets the delay duration for retries.
+ RetryDuration time.Duration
+
+ // UserAgent, if not empty, will be set as the HTTP User-Agent header on all requests sent
+ // through the Do method.
+ UserAgent string
+
+ Jar http.CookieJar
+
+ // Set to true to skip attempted registration of resource providers (false by default).
+ SkipResourceProviderRegistration bool
+}
+
+// NewClientWithUserAgent returns an instance of a Client with the UserAgent set to the passed
+// string.
+func NewClientWithUserAgent(ua string) Client {
+ c := Client{
+ PollingDelay: DefaultPollingDelay,
+ PollingDuration: DefaultPollingDuration,
+ RetryAttempts: DefaultRetryAttempts,
+ RetryDuration: DefaultRetryDuration,
+ UserAgent: UserAgent(),
+ }
+ c.Sender = c.sender()
+ c.AddToUserAgent(ua)
+ return c
+}
+
+// AddToUserAgent adds an extension to the current user agent
+func (c *Client) AddToUserAgent(extension string) error {
+ if extension != "" {
+ c.UserAgent = fmt.Sprintf("%s %s", c.UserAgent, extension)
+ return nil
+ }
+ return fmt.Errorf("Extension was empty, User Agent stayed as %s", c.UserAgent)
+}
+
+// Do implements the Sender interface by invoking the active Sender after applying authorization.
+// If Sender is not set, it uses a new instance of http.Client. In both cases it will, if UserAgent
+// is set, apply set the User-Agent header.
+func (c Client) Do(r *http.Request) (*http.Response, error) {
+ if r.UserAgent() == "" {
+ r, _ = Prepare(r,
+ WithUserAgent(c.UserAgent))
+ }
+ // NOTE: c.WithInspection() must be last in the list so that it can inspect all preceding operations
+ r, err := Prepare(r,
+ c.WithAuthorization(),
+ c.WithInspection())
+ if err != nil {
+ var resp *http.Response
+ if detErr, ok := err.(DetailedError); ok {
+ // if the authorization failed (e.g. invalid credentials) there will
+ // be a response associated with the error, be sure to return it.
+ resp = detErr.Response
+ }
+ return resp, NewErrorWithError(err, "autorest/Client", "Do", nil, "Preparing request failed")
+ }
+ logger.Instance.WriteRequest(r, logger.Filter{
+ Header: func(k string, v []string) (bool, []string) {
+ // remove the auth token from the log
+ if strings.EqualFold(k, "Authorization") || strings.EqualFold(k, "Ocp-Apim-Subscription-Key") {
+ v = []string{"**REDACTED**"}
+ }
+ return true, v
+ },
+ })
+ resp, err := SendWithSender(c.sender(), r)
+ logger.Instance.WriteResponse(resp, logger.Filter{})
+ Respond(resp, c.ByInspecting())
+ return resp, err
+}
+
+// sender returns the Sender to which to send requests.
+func (c Client) sender() Sender {
+ if c.Sender == nil {
+ j, _ := cookiejar.New(nil)
+ client := &http.Client{Jar: j, Transport: tracing.Transport}
+ return client
+ }
+
+ return c.Sender
+}
+
+// WithAuthorization is a convenience method that returns the WithAuthorization PrepareDecorator
+// from the current Authorizer. If not Authorizer is set, it uses the NullAuthorizer.
+func (c Client) WithAuthorization() PrepareDecorator {
+ return c.authorizer().WithAuthorization()
+}
+
+// authorizer returns the Authorizer to use.
+func (c Client) authorizer() Authorizer {
+ if c.Authorizer == nil {
+ return NullAuthorizer{}
+ }
+ return c.Authorizer
+}
+
+// WithInspection is a convenience method that passes the request to the supplied RequestInspector,
+// if present, or returns the WithNothing PrepareDecorator otherwise.
+func (c Client) WithInspection() PrepareDecorator {
+ if c.RequestInspector == nil {
+ return WithNothing()
+ }
+ return c.RequestInspector
+}
+
+// ByInspecting is a convenience method that passes the response to the supplied ResponseInspector,
+// if present, or returns the ByIgnoring RespondDecorator otherwise.
+func (c Client) ByInspecting() RespondDecorator {
+ if c.ResponseInspector == nil {
+ return ByIgnoring()
+ }
+ return c.ResponseInspector
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/date.go b/vendor/github.com/Azure/go-autorest/autorest/date/date.go
new file mode 100644
index 0000000000..c457106568
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/date/date.go
@@ -0,0 +1,96 @@
+/*
+Package date provides time.Time derivatives that conform to the Swagger.io (https://swagger.io/)
+defined date formats: Date and DateTime. Both types may, in most cases, be used in lieu of
+time.Time types. And both convert to time.Time through a ToTime method.
+*/
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "fmt"
+ "time"
+)
+
+const (
+ fullDate = "2006-01-02"
+ fullDateJSON = `"2006-01-02"`
+ dateFormat = "%04d-%02d-%02d"
+ jsonFormat = `"%04d-%02d-%02d"`
+)
+
+// Date defines a type similar to time.Time but assumes a layout of RFC3339 full-date (i.e.,
+// 2006-01-02).
+type Date struct {
+ time.Time
+}
+
+// ParseDate create a new Date from the passed string.
+func ParseDate(date string) (d Date, err error) {
+ return parseDate(date, fullDate)
+}
+
+func parseDate(date string, format string) (Date, error) {
+ d, err := time.Parse(format, date)
+ return Date{Time: d}, err
+}
+
+// MarshalBinary preserves the Date as a byte array conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d Date) MarshalBinary() ([]byte, error) {
+ return d.MarshalText()
+}
+
+// UnmarshalBinary reconstitutes a Date saved as a byte array conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d *Date) UnmarshalBinary(data []byte) error {
+ return d.UnmarshalText(data)
+}
+
+// MarshalJSON preserves the Date as a JSON string conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d Date) MarshalJSON() (json []byte, err error) {
+ return []byte(fmt.Sprintf(jsonFormat, d.Year(), d.Month(), d.Day())), nil
+}
+
+// UnmarshalJSON reconstitutes the Date from a JSON string conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d *Date) UnmarshalJSON(data []byte) (err error) {
+ d.Time, err = time.Parse(fullDateJSON, string(data))
+ return err
+}
+
+// MarshalText preserves the Date as a byte array conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d Date) MarshalText() (text []byte, err error) {
+ return []byte(fmt.Sprintf(dateFormat, d.Year(), d.Month(), d.Day())), nil
+}
+
+// UnmarshalText reconstitutes a Date saved as a byte array conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d *Date) UnmarshalText(data []byte) (err error) {
+ d.Time, err = time.Parse(fullDate, string(data))
+ return err
+}
+
+// String returns the Date formatted as an RFC3339 full-date string (i.e., 2006-01-02).
+func (d Date) String() string {
+ return fmt.Sprintf(dateFormat, d.Year(), d.Month(), d.Day())
+}
+
+// ToTime returns a Date as a time.Time
+func (d Date) ToTime() time.Time {
+ return d.Time
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/time.go b/vendor/github.com/Azure/go-autorest/autorest/date/time.go
new file mode 100644
index 0000000000..b453fad049
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/date/time.go
@@ -0,0 +1,103 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "regexp"
+ "time"
+)
+
+// Azure reports time in UTC but it doesn't include the 'Z' time zone suffix in some cases.
+const (
+ azureUtcFormatJSON = `"2006-01-02T15:04:05.999999999"`
+ azureUtcFormat = "2006-01-02T15:04:05.999999999"
+ rfc3339JSON = `"` + time.RFC3339Nano + `"`
+ rfc3339 = time.RFC3339Nano
+ tzOffsetRegex = `(Z|z|\+|-)(\d+:\d+)*"*$`
+)
+
+// Time defines a type similar to time.Time but assumes a layout of RFC3339 date-time (i.e.,
+// 2006-01-02T15:04:05Z).
+type Time struct {
+ time.Time
+}
+
+// MarshalBinary preserves the Time as a byte array conforming to RFC3339 date-time (i.e.,
+// 2006-01-02T15:04:05Z).
+func (t Time) MarshalBinary() ([]byte, error) {
+ return t.Time.MarshalText()
+}
+
+// UnmarshalBinary reconstitutes a Time saved as a byte array conforming to RFC3339 date-time
+// (i.e., 2006-01-02T15:04:05Z).
+func (t *Time) UnmarshalBinary(data []byte) error {
+ return t.UnmarshalText(data)
+}
+
+// MarshalJSON preserves the Time as a JSON string conforming to RFC3339 date-time (i.e.,
+// 2006-01-02T15:04:05Z).
+func (t Time) MarshalJSON() (json []byte, err error) {
+ return t.Time.MarshalJSON()
+}
+
+// UnmarshalJSON reconstitutes the Time from a JSON string conforming to RFC3339 date-time
+// (i.e., 2006-01-02T15:04:05Z).
+func (t *Time) UnmarshalJSON(data []byte) (err error) {
+ timeFormat := azureUtcFormatJSON
+ match, err := regexp.Match(tzOffsetRegex, data)
+ if err != nil {
+ return err
+ } else if match {
+ timeFormat = rfc3339JSON
+ }
+ t.Time, err = ParseTime(timeFormat, string(data))
+ return err
+}
+
+// MarshalText preserves the Time as a byte array conforming to RFC3339 date-time (i.e.,
+// 2006-01-02T15:04:05Z).
+func (t Time) MarshalText() (text []byte, err error) {
+ return t.Time.MarshalText()
+}
+
+// UnmarshalText reconstitutes a Time saved as a byte array conforming to RFC3339 date-time
+// (i.e., 2006-01-02T15:04:05Z).
+func (t *Time) UnmarshalText(data []byte) (err error) {
+ timeFormat := azureUtcFormat
+ match, err := regexp.Match(tzOffsetRegex, data)
+ if err != nil {
+ return err
+ } else if match {
+ timeFormat = rfc3339
+ }
+ t.Time, err = ParseTime(timeFormat, string(data))
+ return err
+}
+
+// String returns the Time formatted as an RFC3339 date-time string (i.e.,
+// 2006-01-02T15:04:05Z).
+func (t Time) String() string {
+ // Note: time.Time.String does not return an RFC3339 compliant string, time.Time.MarshalText does.
+ b, err := t.MarshalText()
+ if err != nil {
+ return ""
+ }
+ return string(b)
+}
+
+// ToTime returns a Time as a time.Time
+func (t Time) ToTime() time.Time {
+ return t.Time
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/timerfc1123.go b/vendor/github.com/Azure/go-autorest/autorest/date/timerfc1123.go
new file mode 100644
index 0000000000..48fb39ba9b
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/date/timerfc1123.go
@@ -0,0 +1,100 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "errors"
+ "time"
+)
+
+const (
+ rfc1123JSON = `"` + time.RFC1123 + `"`
+ rfc1123 = time.RFC1123
+)
+
+// TimeRFC1123 defines a type similar to time.Time but assumes a layout of RFC1123 date-time (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+type TimeRFC1123 struct {
+ time.Time
+}
+
+// UnmarshalJSON reconstitutes the Time from a JSON string conforming to RFC1123 date-time
+// (i.e., Mon, 02 Jan 2006 15:04:05 MST).
+func (t *TimeRFC1123) UnmarshalJSON(data []byte) (err error) {
+ t.Time, err = ParseTime(rfc1123JSON, string(data))
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// MarshalJSON preserves the Time as a JSON string conforming to RFC1123 date-time (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+func (t TimeRFC1123) MarshalJSON() ([]byte, error) {
+ if y := t.Year(); y < 0 || y >= 10000 {
+ return nil, errors.New("Time.MarshalJSON: year outside of range [0,9999]")
+ }
+ b := []byte(t.Format(rfc1123JSON))
+ return b, nil
+}
+
+// MarshalText preserves the Time as a byte array conforming to RFC1123 date-time (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+func (t TimeRFC1123) MarshalText() ([]byte, error) {
+ if y := t.Year(); y < 0 || y >= 10000 {
+ return nil, errors.New("Time.MarshalText: year outside of range [0,9999]")
+ }
+
+ b := []byte(t.Format(rfc1123))
+ return b, nil
+}
+
+// UnmarshalText reconstitutes a Time saved as a byte array conforming to RFC1123 date-time
+// (i.e., Mon, 02 Jan 2006 15:04:05 MST).
+func (t *TimeRFC1123) UnmarshalText(data []byte) (err error) {
+ t.Time, err = ParseTime(rfc1123, string(data))
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// MarshalBinary preserves the Time as a byte array conforming to RFC1123 date-time (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+func (t TimeRFC1123) MarshalBinary() ([]byte, error) {
+ return t.MarshalText()
+}
+
+// UnmarshalBinary reconstitutes a Time saved as a byte array conforming to RFC1123 date-time
+// (i.e., Mon, 02 Jan 2006 15:04:05 MST).
+func (t *TimeRFC1123) UnmarshalBinary(data []byte) error {
+ return t.UnmarshalText(data)
+}
+
+// ToTime returns a Time as a time.Time
+func (t TimeRFC1123) ToTime() time.Time {
+ return t.Time
+}
+
+// String returns the Time formatted as an RFC1123 date-time string (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+func (t TimeRFC1123) String() string {
+ // Note: time.Time.String does not return an RFC1123 compliant string, time.Time.MarshalText does.
+ b, err := t.MarshalText()
+ if err != nil {
+ return ""
+ }
+ return string(b)
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/unixtime.go b/vendor/github.com/Azure/go-autorest/autorest/date/unixtime.go
new file mode 100644
index 0000000000..7073959b2a
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/date/unixtime.go
@@ -0,0 +1,123 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "encoding/binary"
+ "encoding/json"
+ "time"
+)
+
+// unixEpoch is the moment in time that should be treated as timestamp 0.
+var unixEpoch = time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC)
+
+// UnixTime marshals and unmarshals a time that is represented as the number
+// of seconds (ignoring skip-seconds) since the Unix Epoch.
+type UnixTime time.Time
+
+// Duration returns the time as a Duration since the UnixEpoch.
+func (t UnixTime) Duration() time.Duration {
+ return time.Time(t).Sub(unixEpoch)
+}
+
+// NewUnixTimeFromSeconds creates a UnixTime as a number of seconds from the UnixEpoch.
+func NewUnixTimeFromSeconds(seconds float64) UnixTime {
+ return NewUnixTimeFromDuration(time.Duration(seconds * float64(time.Second)))
+}
+
+// NewUnixTimeFromNanoseconds creates a UnixTime as a number of nanoseconds from the UnixEpoch.
+func NewUnixTimeFromNanoseconds(nanoseconds int64) UnixTime {
+ return NewUnixTimeFromDuration(time.Duration(nanoseconds))
+}
+
+// NewUnixTimeFromDuration creates a UnixTime as a duration of time since the UnixEpoch.
+func NewUnixTimeFromDuration(dur time.Duration) UnixTime {
+ return UnixTime(unixEpoch.Add(dur))
+}
+
+// UnixEpoch retreives the moment considered the Unix Epoch. I.e. The time represented by '0'
+func UnixEpoch() time.Time {
+ return unixEpoch
+}
+
+// MarshalJSON preserves the UnixTime as a JSON number conforming to Unix Timestamp requirements.
+// (i.e. the number of seconds since midnight January 1st, 1970 not considering leap seconds.)
+func (t UnixTime) MarshalJSON() ([]byte, error) {
+ buffer := &bytes.Buffer{}
+ enc := json.NewEncoder(buffer)
+ err := enc.Encode(float64(time.Time(t).UnixNano()) / 1e9)
+ if err != nil {
+ return nil, err
+ }
+ return buffer.Bytes(), nil
+}
+
+// UnmarshalJSON reconstitures a UnixTime saved as a JSON number of the number of seconds since
+// midnight January 1st, 1970.
+func (t *UnixTime) UnmarshalJSON(text []byte) error {
+ dec := json.NewDecoder(bytes.NewReader(text))
+
+ var secondsSinceEpoch float64
+ if err := dec.Decode(&secondsSinceEpoch); err != nil {
+ return err
+ }
+
+ *t = NewUnixTimeFromSeconds(secondsSinceEpoch)
+
+ return nil
+}
+
+// MarshalText stores the number of seconds since the Unix Epoch as a textual floating point number.
+func (t UnixTime) MarshalText() ([]byte, error) {
+ cast := time.Time(t)
+ return cast.MarshalText()
+}
+
+// UnmarshalText populates a UnixTime with a value stored textually as a floating point number of seconds since the Unix Epoch.
+func (t *UnixTime) UnmarshalText(raw []byte) error {
+ var unmarshaled time.Time
+
+ if err := unmarshaled.UnmarshalText(raw); err != nil {
+ return err
+ }
+
+ *t = UnixTime(unmarshaled)
+ return nil
+}
+
+// MarshalBinary converts a UnixTime into a binary.LittleEndian float64 of nanoseconds since the epoch.
+func (t UnixTime) MarshalBinary() ([]byte, error) {
+ buf := &bytes.Buffer{}
+
+ payload := int64(t.Duration())
+
+ if err := binary.Write(buf, binary.LittleEndian, &payload); err != nil {
+ return nil, err
+ }
+
+ return buf.Bytes(), nil
+}
+
+// UnmarshalBinary converts a from a binary.LittleEndian float64 of nanoseconds since the epoch into a UnixTime.
+func (t *UnixTime) UnmarshalBinary(raw []byte) error {
+ var nanosecondsSinceEpoch int64
+
+ if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, &nanosecondsSinceEpoch); err != nil {
+ return err
+ }
+ *t = NewUnixTimeFromNanoseconds(nanosecondsSinceEpoch)
+ return nil
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/utility.go b/vendor/github.com/Azure/go-autorest/autorest/date/utility.go
new file mode 100644
index 0000000000..12addf0ebb
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/date/utility.go
@@ -0,0 +1,25 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "strings"
+ "time"
+)
+
+// ParseTime to parse Time string to specified format.
+func ParseTime(format string, t string) (d time.Time, err error) {
+ return time.Parse(format, strings.ToUpper(t))
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/error.go b/vendor/github.com/Azure/go-autorest/autorest/error.go
new file mode 100644
index 0000000000..f724f33327
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/error.go
@@ -0,0 +1,98 @@
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "fmt"
+ "net/http"
+)
+
+const (
+ // UndefinedStatusCode is used when HTTP status code is not available for an error.
+ UndefinedStatusCode = 0
+)
+
+// DetailedError encloses a error with details of the package, method, and associated HTTP
+// status code (if any).
+type DetailedError struct {
+ Original error
+
+ // PackageType is the package type of the object emitting the error. For types, the value
+ // matches that produced the the '%T' format specifier of the fmt package. For other elements,
+ // such as functions, it is just the package name (e.g., "autorest").
+ PackageType string
+
+ // Method is the name of the method raising the error.
+ Method string
+
+ // StatusCode is the HTTP Response StatusCode (if non-zero) that led to the error.
+ StatusCode interface{}
+
+ // Message is the error message.
+ Message string
+
+ // Service Error is the response body of failed API in bytes
+ ServiceError []byte
+
+ // Response is the response object that was returned during failure if applicable.
+ Response *http.Response
+}
+
+// NewError creates a new Error conforming object from the passed packageType, method, and
+// message. message is treated as a format string to which the optional args apply.
+func NewError(packageType string, method string, message string, args ...interface{}) DetailedError {
+ return NewErrorWithError(nil, packageType, method, nil, message, args...)
+}
+
+// NewErrorWithResponse creates a new Error conforming object from the passed
+// packageType, method, statusCode of the given resp (UndefinedStatusCode if
+// resp is nil), and message. message is treated as a format string to which the
+// optional args apply.
+func NewErrorWithResponse(packageType string, method string, resp *http.Response, message string, args ...interface{}) DetailedError {
+ return NewErrorWithError(nil, packageType, method, resp, message, args...)
+}
+
+// NewErrorWithError creates a new Error conforming object from the
+// passed packageType, method, statusCode of the given resp (UndefinedStatusCode
+// if resp is nil), message, and original error. message is treated as a format
+// string to which the optional args apply.
+func NewErrorWithError(original error, packageType string, method string, resp *http.Response, message string, args ...interface{}) DetailedError {
+ if v, ok := original.(DetailedError); ok {
+ return v
+ }
+
+ statusCode := UndefinedStatusCode
+ if resp != nil {
+ statusCode = resp.StatusCode
+ }
+
+ return DetailedError{
+ Original: original,
+ PackageType: packageType,
+ Method: method,
+ StatusCode: statusCode,
+ Message: fmt.Sprintf(message, args...),
+ Response: resp,
+ }
+}
+
+// Error returns a formatted containing all available details (i.e., PackageType, Method,
+// StatusCode, Message, and original error (if any)).
+func (e DetailedError) Error() string {
+ if e.Original == nil {
+ return fmt.Sprintf("%s#%s: %s: StatusCode=%d", e.PackageType, e.Method, e.Message, e.StatusCode)
+ }
+ return fmt.Sprintf("%s#%s: %s: StatusCode=%d -- Original Error: %v", e.PackageType, e.Method, e.Message, e.StatusCode, e.Original)
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/preparer.go b/vendor/github.com/Azure/go-autorest/autorest/preparer.go
new file mode 100644
index 0000000000..6d67bd7337
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/preparer.go
@@ -0,0 +1,480 @@
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "mime/multipart"
+ "net/http"
+ "net/url"
+ "strings"
+)
+
+const (
+ mimeTypeJSON = "application/json"
+ mimeTypeOctetStream = "application/octet-stream"
+ mimeTypeFormPost = "application/x-www-form-urlencoded"
+
+ headerAuthorization = "Authorization"
+ headerContentType = "Content-Type"
+ headerUserAgent = "User-Agent"
+)
+
+// Preparer is the interface that wraps the Prepare method.
+//
+// Prepare accepts and possibly modifies an http.Request (e.g., adding Headers). Implementations
+// must ensure to not share or hold per-invocation state since Preparers may be shared and re-used.
+type Preparer interface {
+ Prepare(*http.Request) (*http.Request, error)
+}
+
+// PreparerFunc is a method that implements the Preparer interface.
+type PreparerFunc func(*http.Request) (*http.Request, error)
+
+// Prepare implements the Preparer interface on PreparerFunc.
+func (pf PreparerFunc) Prepare(r *http.Request) (*http.Request, error) {
+ return pf(r)
+}
+
+// PrepareDecorator takes and possibly decorates, by wrapping, a Preparer. Decorators may affect the
+// http.Request and pass it along or, first, pass the http.Request along then affect the result.
+type PrepareDecorator func(Preparer) Preparer
+
+// CreatePreparer creates, decorates, and returns a Preparer.
+// Without decorators, the returned Preparer returns the passed http.Request unmodified.
+// Preparers are safe to share and re-use.
+func CreatePreparer(decorators ...PrepareDecorator) Preparer {
+ return DecoratePreparer(
+ Preparer(PreparerFunc(func(r *http.Request) (*http.Request, error) { return r, nil })),
+ decorators...)
+}
+
+// DecoratePreparer accepts a Preparer and a, possibly empty, set of PrepareDecorators, which it
+// applies to the Preparer. Decorators are applied in the order received, but their affect upon the
+// request depends on whether they are a pre-decorator (change the http.Request and then pass it
+// along) or a post-decorator (pass the http.Request along and alter it on return).
+func DecoratePreparer(p Preparer, decorators ...PrepareDecorator) Preparer {
+ for _, decorate := range decorators {
+ p = decorate(p)
+ }
+ return p
+}
+
+// Prepare accepts an http.Request and a, possibly empty, set of PrepareDecorators.
+// It creates a Preparer from the decorators which it then applies to the passed http.Request.
+func Prepare(r *http.Request, decorators ...PrepareDecorator) (*http.Request, error) {
+ if r == nil {
+ return nil, NewError("autorest", "Prepare", "Invoked without an http.Request")
+ }
+ return CreatePreparer(decorators...).Prepare(r)
+}
+
+// WithNothing returns a "do nothing" PrepareDecorator that makes no changes to the passed
+// http.Request.
+func WithNothing() PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ return p.Prepare(r)
+ })
+ }
+}
+
+// WithHeader returns a PrepareDecorator that sets the specified HTTP header of the http.Request to
+// the passed value. It canonicalizes the passed header name (via http.CanonicalHeaderKey) before
+// adding the header.
+func WithHeader(header string, value string) PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ if r.Header == nil {
+ r.Header = make(http.Header)
+ }
+ r.Header.Set(http.CanonicalHeaderKey(header), value)
+ }
+ return r, err
+ })
+ }
+}
+
+// WithHeaders returns a PrepareDecorator that sets the specified HTTP headers of the http.Request to
+// the passed value. It canonicalizes the passed headers name (via http.CanonicalHeaderKey) before
+// adding them.
+func WithHeaders(headers map[string]interface{}) PrepareDecorator {
+ h := ensureValueStrings(headers)
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ if r.Header == nil {
+ r.Header = make(http.Header)
+ }
+
+ for name, value := range h {
+ r.Header.Set(http.CanonicalHeaderKey(name), value)
+ }
+ }
+ return r, err
+ })
+ }
+}
+
+// WithBearerAuthorization returns a PrepareDecorator that adds an HTTP Authorization header whose
+// value is "Bearer " followed by the supplied token.
+func WithBearerAuthorization(token string) PrepareDecorator {
+ return WithHeader(headerAuthorization, fmt.Sprintf("Bearer %s", token))
+}
+
+// AsContentType returns a PrepareDecorator that adds an HTTP Content-Type header whose value
+// is the passed contentType.
+func AsContentType(contentType string) PrepareDecorator {
+ return WithHeader(headerContentType, contentType)
+}
+
+// WithUserAgent returns a PrepareDecorator that adds an HTTP User-Agent header whose value is the
+// passed string.
+func WithUserAgent(ua string) PrepareDecorator {
+ return WithHeader(headerUserAgent, ua)
+}
+
+// AsFormURLEncoded returns a PrepareDecorator that adds an HTTP Content-Type header whose value is
+// "application/x-www-form-urlencoded".
+func AsFormURLEncoded() PrepareDecorator {
+ return AsContentType(mimeTypeFormPost)
+}
+
+// AsJSON returns a PrepareDecorator that adds an HTTP Content-Type header whose value is
+// "application/json".
+func AsJSON() PrepareDecorator {
+ return AsContentType(mimeTypeJSON)
+}
+
+// AsOctetStream returns a PrepareDecorator that adds the "application/octet-stream" Content-Type header.
+func AsOctetStream() PrepareDecorator {
+ return AsContentType(mimeTypeOctetStream)
+}
+
+// WithMethod returns a PrepareDecorator that sets the HTTP method of the passed request. The
+// decorator does not validate that the passed method string is a known HTTP method.
+func WithMethod(method string) PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r.Method = method
+ return p.Prepare(r)
+ })
+ }
+}
+
+// AsDelete returns a PrepareDecorator that sets the HTTP method to DELETE.
+func AsDelete() PrepareDecorator { return WithMethod("DELETE") }
+
+// AsGet returns a PrepareDecorator that sets the HTTP method to GET.
+func AsGet() PrepareDecorator { return WithMethod("GET") }
+
+// AsHead returns a PrepareDecorator that sets the HTTP method to HEAD.
+func AsHead() PrepareDecorator { return WithMethod("HEAD") }
+
+// AsOptions returns a PrepareDecorator that sets the HTTP method to OPTIONS.
+func AsOptions() PrepareDecorator { return WithMethod("OPTIONS") }
+
+// AsPatch returns a PrepareDecorator that sets the HTTP method to PATCH.
+func AsPatch() PrepareDecorator { return WithMethod("PATCH") }
+
+// AsPost returns a PrepareDecorator that sets the HTTP method to POST.
+func AsPost() PrepareDecorator { return WithMethod("POST") }
+
+// AsPut returns a PrepareDecorator that sets the HTTP method to PUT.
+func AsPut() PrepareDecorator { return WithMethod("PUT") }
+
+// WithBaseURL returns a PrepareDecorator that populates the http.Request with a url.URL constructed
+// from the supplied baseUrl.
+func WithBaseURL(baseURL string) PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ var u *url.URL
+ if u, err = url.Parse(baseURL); err != nil {
+ return r, err
+ }
+ if u.Scheme == "" {
+ err = fmt.Errorf("autorest: No scheme detected in URL %s", baseURL)
+ }
+ if err == nil {
+ r.URL = u
+ }
+ }
+ return r, err
+ })
+ }
+}
+
+// WithCustomBaseURL returns a PrepareDecorator that replaces brace-enclosed keys within the
+// request base URL (i.e., http.Request.URL) with the corresponding values from the passed map.
+func WithCustomBaseURL(baseURL string, urlParameters map[string]interface{}) PrepareDecorator {
+ parameters := ensureValueStrings(urlParameters)
+ for key, value := range parameters {
+ baseURL = strings.Replace(baseURL, "{"+key+"}", value, -1)
+ }
+ return WithBaseURL(baseURL)
+}
+
+// WithFormData returns a PrepareDecoratore that "URL encodes" (e.g., bar=baz&foo=quux) into the
+// http.Request body.
+func WithFormData(v url.Values) PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ s := v.Encode()
+
+ if r.Header == nil {
+ r.Header = make(http.Header)
+ }
+ r.Header.Set(http.CanonicalHeaderKey(headerContentType), mimeTypeFormPost)
+ r.ContentLength = int64(len(s))
+ r.Body = ioutil.NopCloser(strings.NewReader(s))
+ }
+ return r, err
+ })
+ }
+}
+
+// WithMultiPartFormData returns a PrepareDecoratore that "URL encodes" (e.g., bar=baz&foo=quux) form parameters
+// into the http.Request body.
+func WithMultiPartFormData(formDataParameters map[string]interface{}) PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ var body bytes.Buffer
+ writer := multipart.NewWriter(&body)
+ for key, value := range formDataParameters {
+ if rc, ok := value.(io.ReadCloser); ok {
+ var fd io.Writer
+ if fd, err = writer.CreateFormFile(key, key); err != nil {
+ return r, err
+ }
+ if _, err = io.Copy(fd, rc); err != nil {
+ return r, err
+ }
+ } else {
+ if err = writer.WriteField(key, ensureValueString(value)); err != nil {
+ return r, err
+ }
+ }
+ }
+ if err = writer.Close(); err != nil {
+ return r, err
+ }
+ if r.Header == nil {
+ r.Header = make(http.Header)
+ }
+ r.Header.Set(http.CanonicalHeaderKey(headerContentType), writer.FormDataContentType())
+ r.Body = ioutil.NopCloser(bytes.NewReader(body.Bytes()))
+ r.ContentLength = int64(body.Len())
+ return r, err
+ }
+ return r, err
+ })
+ }
+}
+
+// WithFile returns a PrepareDecorator that sends file in request body.
+func WithFile(f io.ReadCloser) PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ b, err := ioutil.ReadAll(f)
+ if err != nil {
+ return r, err
+ }
+ r.Body = ioutil.NopCloser(bytes.NewReader(b))
+ r.ContentLength = int64(len(b))
+ }
+ return r, err
+ })
+ }
+}
+
+// WithBool returns a PrepareDecorator that encodes the passed bool into the body of the request
+// and sets the Content-Length header.
+func WithBool(v bool) PrepareDecorator {
+ return WithString(fmt.Sprintf("%v", v))
+}
+
+// WithFloat32 returns a PrepareDecorator that encodes the passed float32 into the body of the
+// request and sets the Content-Length header.
+func WithFloat32(v float32) PrepareDecorator {
+ return WithString(fmt.Sprintf("%v", v))
+}
+
+// WithFloat64 returns a PrepareDecorator that encodes the passed float64 into the body of the
+// request and sets the Content-Length header.
+func WithFloat64(v float64) PrepareDecorator {
+ return WithString(fmt.Sprintf("%v", v))
+}
+
+// WithInt32 returns a PrepareDecorator that encodes the passed int32 into the body of the request
+// and sets the Content-Length header.
+func WithInt32(v int32) PrepareDecorator {
+ return WithString(fmt.Sprintf("%v", v))
+}
+
+// WithInt64 returns a PrepareDecorator that encodes the passed int64 into the body of the request
+// and sets the Content-Length header.
+func WithInt64(v int64) PrepareDecorator {
+ return WithString(fmt.Sprintf("%v", v))
+}
+
+// WithString returns a PrepareDecorator that encodes the passed string into the body of the request
+// and sets the Content-Length header.
+func WithString(v string) PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ r.ContentLength = int64(len(v))
+ r.Body = ioutil.NopCloser(strings.NewReader(v))
+ }
+ return r, err
+ })
+ }
+}
+
+// WithJSON returns a PrepareDecorator that encodes the data passed as JSON into the body of the
+// request and sets the Content-Length header.
+func WithJSON(v interface{}) PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ b, err := json.Marshal(v)
+ if err == nil {
+ r.ContentLength = int64(len(b))
+ r.Body = ioutil.NopCloser(bytes.NewReader(b))
+ }
+ }
+ return r, err
+ })
+ }
+}
+
+// WithPath returns a PrepareDecorator that adds the supplied path to the request URL. If the path
+// is absolute (that is, it begins with a "/"), it replaces the existing path.
+func WithPath(path string) PrepareDecorator {
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ if r.URL == nil {
+ return r, NewError("autorest", "WithPath", "Invoked with a nil URL")
+ }
+ if r.URL, err = parseURL(r.URL, path); err != nil {
+ return r, err
+ }
+ }
+ return r, err
+ })
+ }
+}
+
+// WithEscapedPathParameters returns a PrepareDecorator that replaces brace-enclosed keys within the
+// request path (i.e., http.Request.URL.Path) with the corresponding values from the passed map. The
+// values will be escaped (aka URL encoded) before insertion into the path.
+func WithEscapedPathParameters(path string, pathParameters map[string]interface{}) PrepareDecorator {
+ parameters := escapeValueStrings(ensureValueStrings(pathParameters))
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ if r.URL == nil {
+ return r, NewError("autorest", "WithEscapedPathParameters", "Invoked with a nil URL")
+ }
+ for key, value := range parameters {
+ path = strings.Replace(path, "{"+key+"}", value, -1)
+ }
+ if r.URL, err = parseURL(r.URL, path); err != nil {
+ return r, err
+ }
+ }
+ return r, err
+ })
+ }
+}
+
+// WithPathParameters returns a PrepareDecorator that replaces brace-enclosed keys within the
+// request path (i.e., http.Request.URL.Path) with the corresponding values from the passed map.
+func WithPathParameters(path string, pathParameters map[string]interface{}) PrepareDecorator {
+ parameters := ensureValueStrings(pathParameters)
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ if r.URL == nil {
+ return r, NewError("autorest", "WithPathParameters", "Invoked with a nil URL")
+ }
+ for key, value := range parameters {
+ path = strings.Replace(path, "{"+key+"}", value, -1)
+ }
+
+ if r.URL, err = parseURL(r.URL, path); err != nil {
+ return r, err
+ }
+ }
+ return r, err
+ })
+ }
+}
+
+func parseURL(u *url.URL, path string) (*url.URL, error) {
+ p := strings.TrimRight(u.String(), "/")
+ if !strings.HasPrefix(path, "/") {
+ path = "/" + path
+ }
+ return url.Parse(p + path)
+}
+
+// WithQueryParameters returns a PrepareDecorators that encodes and applies the query parameters
+// given in the supplied map (i.e., key=value).
+func WithQueryParameters(queryParameters map[string]interface{}) PrepareDecorator {
+ parameters := ensureValueStrings(queryParameters)
+ return func(p Preparer) Preparer {
+ return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+ r, err := p.Prepare(r)
+ if err == nil {
+ if r.URL == nil {
+ return r, NewError("autorest", "WithQueryParameters", "Invoked with a nil URL")
+ }
+
+ v := r.URL.Query()
+ for key, value := range parameters {
+ d, err := url.QueryUnescape(value)
+ if err != nil {
+ return r, err
+ }
+ v.Add(key, d)
+ }
+ r.URL.RawQuery = v.Encode()
+ }
+ return r, err
+ })
+ }
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/responder.go b/vendor/github.com/Azure/go-autorest/autorest/responder.go
new file mode 100644
index 0000000000..a908a0adb7
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/responder.go
@@ -0,0 +1,250 @@
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "encoding/json"
+ "encoding/xml"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "strings"
+)
+
+// Responder is the interface that wraps the Respond method.
+//
+// Respond accepts and reacts to an http.Response. Implementations must ensure to not share or hold
+// state since Responders may be shared and re-used.
+type Responder interface {
+ Respond(*http.Response) error
+}
+
+// ResponderFunc is a method that implements the Responder interface.
+type ResponderFunc func(*http.Response) error
+
+// Respond implements the Responder interface on ResponderFunc.
+func (rf ResponderFunc) Respond(r *http.Response) error {
+ return rf(r)
+}
+
+// RespondDecorator takes and possibly decorates, by wrapping, a Responder. Decorators may react to
+// the http.Response and pass it along or, first, pass the http.Response along then react.
+type RespondDecorator func(Responder) Responder
+
+// CreateResponder creates, decorates, and returns a Responder. Without decorators, the returned
+// Responder returns the passed http.Response unmodified. Responders may or may not be safe to share
+// and re-used: It depends on the applied decorators. For example, a standard decorator that closes
+// the response body is fine to share whereas a decorator that reads the body into a passed struct
+// is not.
+//
+// To prevent memory leaks, ensure that at least one Responder closes the response body.
+func CreateResponder(decorators ...RespondDecorator) Responder {
+ return DecorateResponder(
+ Responder(ResponderFunc(func(r *http.Response) error { return nil })),
+ decorators...)
+}
+
+// DecorateResponder accepts a Responder and a, possibly empty, set of RespondDecorators, which it
+// applies to the Responder. Decorators are applied in the order received, but their affect upon the
+// request depends on whether they are a pre-decorator (react to the http.Response and then pass it
+// along) or a post-decorator (pass the http.Response along and then react).
+func DecorateResponder(r Responder, decorators ...RespondDecorator) Responder {
+ for _, decorate := range decorators {
+ r = decorate(r)
+ }
+ return r
+}
+
+// Respond accepts an http.Response and a, possibly empty, set of RespondDecorators.
+// It creates a Responder from the decorators it then applies to the passed http.Response.
+func Respond(r *http.Response, decorators ...RespondDecorator) error {
+ if r == nil {
+ return nil
+ }
+ return CreateResponder(decorators...).Respond(r)
+}
+
+// ByIgnoring returns a RespondDecorator that ignores the passed http.Response passing it unexamined
+// to the next RespondDecorator.
+func ByIgnoring() RespondDecorator {
+ return func(r Responder) Responder {
+ return ResponderFunc(func(resp *http.Response) error {
+ return r.Respond(resp)
+ })
+ }
+}
+
+// ByCopying copies the contents of the http.Response Body into the passed bytes.Buffer as
+// the Body is read.
+func ByCopying(b *bytes.Buffer) RespondDecorator {
+ return func(r Responder) Responder {
+ return ResponderFunc(func(resp *http.Response) error {
+ err := r.Respond(resp)
+ if err == nil && resp != nil && resp.Body != nil {
+ resp.Body = TeeReadCloser(resp.Body, b)
+ }
+ return err
+ })
+ }
+}
+
+// ByDiscardingBody returns a RespondDecorator that first invokes the passed Responder after which
+// it copies the remaining bytes (if any) in the response body to ioutil.Discard. Since the passed
+// Responder is invoked prior to discarding the response body, the decorator may occur anywhere
+// within the set.
+func ByDiscardingBody() RespondDecorator {
+ return func(r Responder) Responder {
+ return ResponderFunc(func(resp *http.Response) error {
+ err := r.Respond(resp)
+ if err == nil && resp != nil && resp.Body != nil {
+ if _, err := io.Copy(ioutil.Discard, resp.Body); err != nil {
+ return fmt.Errorf("Error discarding the response body: %v", err)
+ }
+ }
+ return err
+ })
+ }
+}
+
+// ByClosing returns a RespondDecorator that first invokes the passed Responder after which it
+// closes the response body. Since the passed Responder is invoked prior to closing the response
+// body, the decorator may occur anywhere within the set.
+func ByClosing() RespondDecorator {
+ return func(r Responder) Responder {
+ return ResponderFunc(func(resp *http.Response) error {
+ err := r.Respond(resp)
+ if resp != nil && resp.Body != nil {
+ if err := resp.Body.Close(); err != nil {
+ return fmt.Errorf("Error closing the response body: %v", err)
+ }
+ }
+ return err
+ })
+ }
+}
+
+// ByClosingIfError returns a RespondDecorator that first invokes the passed Responder after which
+// it closes the response if the passed Responder returns an error and the response body exists.
+func ByClosingIfError() RespondDecorator {
+ return func(r Responder) Responder {
+ return ResponderFunc(func(resp *http.Response) error {
+ err := r.Respond(resp)
+ if err != nil && resp != nil && resp.Body != nil {
+ if err := resp.Body.Close(); err != nil {
+ return fmt.Errorf("Error closing the response body: %v", err)
+ }
+ }
+ return err
+ })
+ }
+}
+
+// ByUnmarshallingJSON returns a RespondDecorator that decodes a JSON document returned in the
+// response Body into the value pointed to by v.
+func ByUnmarshallingJSON(v interface{}) RespondDecorator {
+ return func(r Responder) Responder {
+ return ResponderFunc(func(resp *http.Response) error {
+ err := r.Respond(resp)
+ if err == nil {
+ b, errInner := ioutil.ReadAll(resp.Body)
+ // Some responses might include a BOM, remove for successful unmarshalling
+ b = bytes.TrimPrefix(b, []byte("\xef\xbb\xbf"))
+ if errInner != nil {
+ err = fmt.Errorf("Error occurred reading http.Response#Body - Error = '%v'", errInner)
+ } else if len(strings.Trim(string(b), " ")) > 0 {
+ errInner = json.Unmarshal(b, v)
+ if errInner != nil {
+ err = fmt.Errorf("Error occurred unmarshalling JSON - Error = '%v' JSON = '%s'", errInner, string(b))
+ }
+ }
+ }
+ return err
+ })
+ }
+}
+
+// ByUnmarshallingXML returns a RespondDecorator that decodes a XML document returned in the
+// response Body into the value pointed to by v.
+func ByUnmarshallingXML(v interface{}) RespondDecorator {
+ return func(r Responder) Responder {
+ return ResponderFunc(func(resp *http.Response) error {
+ err := r.Respond(resp)
+ if err == nil {
+ b, errInner := ioutil.ReadAll(resp.Body)
+ if errInner != nil {
+ err = fmt.Errorf("Error occurred reading http.Response#Body - Error = '%v'", errInner)
+ } else {
+ errInner = xml.Unmarshal(b, v)
+ if errInner != nil {
+ err = fmt.Errorf("Error occurred unmarshalling Xml - Error = '%v' Xml = '%s'", errInner, string(b))
+ }
+ }
+ }
+ return err
+ })
+ }
+}
+
+// WithErrorUnlessStatusCode returns a RespondDecorator that emits an error unless the response
+// StatusCode is among the set passed. On error, response body is fully read into a buffer and
+// presented in the returned error, as well as in the response body.
+func WithErrorUnlessStatusCode(codes ...int) RespondDecorator {
+ return func(r Responder) Responder {
+ return ResponderFunc(func(resp *http.Response) error {
+ err := r.Respond(resp)
+ if err == nil && !ResponseHasStatusCode(resp, codes...) {
+ derr := NewErrorWithResponse("autorest", "WithErrorUnlessStatusCode", resp, "%v %v failed with %s",
+ resp.Request.Method,
+ resp.Request.URL,
+ resp.Status)
+ if resp.Body != nil {
+ defer resp.Body.Close()
+ b, _ := ioutil.ReadAll(resp.Body)
+ derr.ServiceError = b
+ resp.Body = ioutil.NopCloser(bytes.NewReader(b))
+ }
+ err = derr
+ }
+ return err
+ })
+ }
+}
+
+// WithErrorUnlessOK returns a RespondDecorator that emits an error if the response StatusCode is
+// anything other than HTTP 200.
+func WithErrorUnlessOK() RespondDecorator {
+ return WithErrorUnlessStatusCode(http.StatusOK)
+}
+
+// ExtractHeader extracts all values of the specified header from the http.Response. It returns an
+// empty string slice if the passed http.Response is nil or the header does not exist.
+func ExtractHeader(header string, resp *http.Response) []string {
+ if resp != nil && resp.Header != nil {
+ return resp.Header[http.CanonicalHeaderKey(header)]
+ }
+ return nil
+}
+
+// ExtractHeaderValue extracts the first value of the specified header from the http.Response. It
+// returns an empty string if the passed http.Response is nil or the header does not exist.
+func ExtractHeaderValue(header string, resp *http.Response) string {
+ h := ExtractHeader(header, resp)
+ if len(h) > 0 {
+ return h[0]
+ }
+ return ""
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/retriablerequest.go b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest.go
new file mode 100644
index 0000000000..fa11dbed79
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest.go
@@ -0,0 +1,52 @@
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "io"
+ "io/ioutil"
+ "net/http"
+)
+
+// NewRetriableRequest returns a wrapper around an HTTP request that support retry logic.
+func NewRetriableRequest(req *http.Request) *RetriableRequest {
+ return &RetriableRequest{req: req}
+}
+
+// Request returns the wrapped HTTP request.
+func (rr *RetriableRequest) Request() *http.Request {
+ return rr.req
+}
+
+func (rr *RetriableRequest) prepareFromByteReader() (err error) {
+ // fall back to making a copy (only do this once)
+ b := []byte{}
+ if rr.req.ContentLength > 0 {
+ b = make([]byte, rr.req.ContentLength)
+ _, err = io.ReadFull(rr.req.Body, b)
+ if err != nil {
+ return err
+ }
+ } else {
+ b, err = ioutil.ReadAll(rr.req.Body)
+ if err != nil {
+ return err
+ }
+ }
+ rr.br = bytes.NewReader(b)
+ rr.req.Body = ioutil.NopCloser(rr.br)
+ return err
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.7.go b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.7.go
new file mode 100644
index 0000000000..7143cc61b5
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.7.go
@@ -0,0 +1,54 @@
+// +build !go1.8
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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 autorest
+
+import (
+ "bytes"
+ "io/ioutil"
+ "net/http"
+)
+
+// RetriableRequest provides facilities for retrying an HTTP request.
+type RetriableRequest struct {
+ req *http.Request
+ br *bytes.Reader
+}
+
+// Prepare signals that the request is about to be sent.
+func (rr *RetriableRequest) Prepare() (err error) {
+ // preserve the request body; this is to support retry logic as
+ // the underlying transport will always close the reqeust body
+ if rr.req.Body != nil {
+ if rr.br != nil {
+ _, err = rr.br.Seek(0, 0 /*io.SeekStart*/)
+ rr.req.Body = ioutil.NopCloser(rr.br)
+ }
+ if err != nil {
+ return err
+ }
+ if rr.br == nil {
+ // fall back to making a copy (only do this once)
+ err = rr.prepareFromByteReader()
+ }
+ }
+ return err
+}
+
+func removeRequestBody(req *http.Request) {
+ req.Body = nil
+ req.ContentLength = 0
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.8.go b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.8.go
new file mode 100644
index 0000000000..ae15c6bf96
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.8.go
@@ -0,0 +1,66 @@
+// +build go1.8
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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 autorest
+
+import (
+ "bytes"
+ "io"
+ "io/ioutil"
+ "net/http"
+)
+
+// RetriableRequest provides facilities for retrying an HTTP request.
+type RetriableRequest struct {
+ req *http.Request
+ rc io.ReadCloser
+ br *bytes.Reader
+}
+
+// Prepare signals that the request is about to be sent.
+func (rr *RetriableRequest) Prepare() (err error) {
+ // preserve the request body; this is to support retry logic as
+ // the underlying transport will always close the reqeust body
+ if rr.req.Body != nil {
+ if rr.rc != nil {
+ rr.req.Body = rr.rc
+ } else if rr.br != nil {
+ _, err = rr.br.Seek(0, io.SeekStart)
+ rr.req.Body = ioutil.NopCloser(rr.br)
+ }
+ if err != nil {
+ return err
+ }
+ if rr.req.GetBody != nil {
+ // this will allow us to preserve the body without having to
+ // make a copy. note we need to do this on each iteration
+ rr.rc, err = rr.req.GetBody()
+ if err != nil {
+ return err
+ }
+ } else if rr.br == nil {
+ // fall back to making a copy (only do this once)
+ err = rr.prepareFromByteReader()
+ }
+ }
+ return err
+}
+
+func removeRequestBody(req *http.Request) {
+ req.Body = nil
+ req.GetBody = nil
+ req.ContentLength = 0
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/sender.go b/vendor/github.com/Azure/go-autorest/autorest/sender.go
new file mode 100644
index 0000000000..6665d7c006
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/sender.go
@@ -0,0 +1,326 @@
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "fmt"
+ "log"
+ "math"
+ "net/http"
+ "strconv"
+ "time"
+
+ "github.com/Azure/go-autorest/tracing"
+)
+
+// Sender is the interface that wraps the Do method to send HTTP requests.
+//
+// The standard http.Client conforms to this interface.
+type Sender interface {
+ Do(*http.Request) (*http.Response, error)
+}
+
+// SenderFunc is a method that implements the Sender interface.
+type SenderFunc func(*http.Request) (*http.Response, error)
+
+// Do implements the Sender interface on SenderFunc.
+func (sf SenderFunc) Do(r *http.Request) (*http.Response, error) {
+ return sf(r)
+}
+
+// SendDecorator takes and possibly decorates, by wrapping, a Sender. Decorators may affect the
+// http.Request and pass it along or, first, pass the http.Request along then react to the
+// http.Response result.
+type SendDecorator func(Sender) Sender
+
+// CreateSender creates, decorates, and returns, as a Sender, the default http.Client.
+func CreateSender(decorators ...SendDecorator) Sender {
+ return DecorateSender(&http.Client{}, decorators...)
+}
+
+// DecorateSender accepts a Sender and a, possibly empty, set of SendDecorators, which is applies to
+// the Sender. Decorators are applied in the order received, but their affect upon the request
+// depends on whether they are a pre-decorator (change the http.Request and then pass it along) or a
+// post-decorator (pass the http.Request along and react to the results in http.Response).
+func DecorateSender(s Sender, decorators ...SendDecorator) Sender {
+ for _, decorate := range decorators {
+ s = decorate(s)
+ }
+ return s
+}
+
+// Send sends, by means of the default http.Client, the passed http.Request, returning the
+// http.Response and possible error. It also accepts a, possibly empty, set of SendDecorators which
+// it will apply the http.Client before invoking the Do method.
+//
+// Send is a convenience method and not recommended for production. Advanced users should use
+// SendWithSender, passing and sharing their own Sender (e.g., instance of http.Client).
+//
+// Send will not poll or retry requests.
+func Send(r *http.Request, decorators ...SendDecorator) (*http.Response, error) {
+ return SendWithSender(&http.Client{Transport: tracing.Transport}, r, decorators...)
+}
+
+// SendWithSender sends the passed http.Request, through the provided Sender, returning the
+// http.Response and possible error. It also accepts a, possibly empty, set of SendDecorators which
+// it will apply the http.Client before invoking the Do method.
+//
+// SendWithSender will not poll or retry requests.
+func SendWithSender(s Sender, r *http.Request, decorators ...SendDecorator) (*http.Response, error) {
+ return DecorateSender(s, decorators...).Do(r)
+}
+
+// AfterDelay returns a SendDecorator that delays for the passed time.Duration before
+// invoking the Sender. The delay may be terminated by closing the optional channel on the
+// http.Request. If canceled, no further Senders are invoked.
+func AfterDelay(d time.Duration) SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (*http.Response, error) {
+ if !DelayForBackoff(d, 0, r.Context().Done()) {
+ return nil, fmt.Errorf("autorest: AfterDelay canceled before full delay")
+ }
+ return s.Do(r)
+ })
+ }
+}
+
+// AsIs returns a SendDecorator that invokes the passed Sender without modifying the http.Request.
+func AsIs() SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (*http.Response, error) {
+ return s.Do(r)
+ })
+ }
+}
+
+// DoCloseIfError returns a SendDecorator that first invokes the passed Sender after which
+// it closes the response if the passed Sender returns an error and the response body exists.
+func DoCloseIfError() SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (*http.Response, error) {
+ resp, err := s.Do(r)
+ if err != nil {
+ Respond(resp, ByDiscardingBody(), ByClosing())
+ }
+ return resp, err
+ })
+ }
+}
+
+// DoErrorIfStatusCode returns a SendDecorator that emits an error if the response StatusCode is
+// among the set passed. Since these are artificial errors, the response body may still require
+// closing.
+func DoErrorIfStatusCode(codes ...int) SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (*http.Response, error) {
+ resp, err := s.Do(r)
+ if err == nil && ResponseHasStatusCode(resp, codes...) {
+ err = NewErrorWithResponse("autorest", "DoErrorIfStatusCode", resp, "%v %v failed with %s",
+ resp.Request.Method,
+ resp.Request.URL,
+ resp.Status)
+ }
+ return resp, err
+ })
+ }
+}
+
+// DoErrorUnlessStatusCode returns a SendDecorator that emits an error unless the response
+// StatusCode is among the set passed. Since these are artificial errors, the response body
+// may still require closing.
+func DoErrorUnlessStatusCode(codes ...int) SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (*http.Response, error) {
+ resp, err := s.Do(r)
+ if err == nil && !ResponseHasStatusCode(resp, codes...) {
+ err = NewErrorWithResponse("autorest", "DoErrorUnlessStatusCode", resp, "%v %v failed with %s",
+ resp.Request.Method,
+ resp.Request.URL,
+ resp.Status)
+ }
+ return resp, err
+ })
+ }
+}
+
+// DoPollForStatusCodes returns a SendDecorator that polls if the http.Response contains one of the
+// passed status codes. It expects the http.Response to contain a Location header providing the
+// URL at which to poll (using GET) and will poll until the time passed is equal to or greater than
+// the supplied duration. It will delay between requests for the duration specified in the
+// RetryAfter header or, if the header is absent, the passed delay. Polling may be canceled by
+// closing the optional channel on the http.Request.
+func DoPollForStatusCodes(duration time.Duration, delay time.Duration, codes ...int) SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (resp *http.Response, err error) {
+ resp, err = s.Do(r)
+
+ if err == nil && ResponseHasStatusCode(resp, codes...) {
+ r, err = NewPollingRequestWithContext(r.Context(), resp)
+
+ for err == nil && ResponseHasStatusCode(resp, codes...) {
+ Respond(resp,
+ ByDiscardingBody(),
+ ByClosing())
+ resp, err = SendWithSender(s, r,
+ AfterDelay(GetRetryAfter(resp, delay)))
+ }
+ }
+
+ return resp, err
+ })
+ }
+}
+
+// DoRetryForAttempts returns a SendDecorator that retries a failed request for up to the specified
+// number of attempts, exponentially backing off between requests using the supplied backoff
+// time.Duration (which may be zero). Retrying may be canceled by closing the optional channel on
+// the http.Request.
+func DoRetryForAttempts(attempts int, backoff time.Duration) SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (resp *http.Response, err error) {
+ rr := NewRetriableRequest(r)
+ for attempt := 0; attempt < attempts; attempt++ {
+ err = rr.Prepare()
+ if err != nil {
+ return resp, err
+ }
+ resp, err = s.Do(rr.Request())
+ if err == nil {
+ return resp, err
+ }
+ if !DelayForBackoff(backoff, attempt, r.Context().Done()) {
+ return nil, r.Context().Err()
+ }
+ }
+ return resp, err
+ })
+ }
+}
+
+// DoRetryForStatusCodes returns a SendDecorator that retries for specified statusCodes for up to the specified
+// number of attempts, exponentially backing off between requests using the supplied backoff
+// time.Duration (which may be zero). Retrying may be canceled by closing the optional channel on
+// the http.Request.
+func DoRetryForStatusCodes(attempts int, backoff time.Duration, codes ...int) SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (resp *http.Response, err error) {
+ rr := NewRetriableRequest(r)
+ // Increment to add the first call (attempts denotes number of retries)
+ for attempt := 0; attempt < attempts+1; {
+ err = rr.Prepare()
+ if err != nil {
+ return resp, err
+ }
+ resp, err = s.Do(rr.Request())
+ // if the error isn't temporary don't bother retrying
+ if err != nil && !IsTemporaryNetworkError(err) {
+ return nil, err
+ }
+ // we want to retry if err is not nil (e.g. transient network failure). note that for failed authentication
+ // resp and err will both have a value, so in this case we don't want to retry as it will never succeed.
+ if err == nil && !ResponseHasStatusCode(resp, codes...) || IsTokenRefreshError(err) {
+ return resp, err
+ }
+ delayed := DelayWithRetryAfter(resp, r.Context().Done())
+ if !delayed && !DelayForBackoff(backoff, attempt, r.Context().Done()) {
+ return resp, r.Context().Err()
+ }
+ // don't count a 429 against the number of attempts
+ // so that we continue to retry until it succeeds
+ if resp == nil || resp.StatusCode != http.StatusTooManyRequests {
+ attempt++
+ }
+ }
+ return resp, err
+ })
+ }
+}
+
+// DelayWithRetryAfter invokes time.After for the duration specified in the "Retry-After" header in
+// responses with status code 429
+func DelayWithRetryAfter(resp *http.Response, cancel <-chan struct{}) bool {
+ if resp == nil {
+ return false
+ }
+ retryAfter, _ := strconv.Atoi(resp.Header.Get("Retry-After"))
+ if resp.StatusCode == http.StatusTooManyRequests && retryAfter > 0 {
+ select {
+ case <-time.After(time.Duration(retryAfter) * time.Second):
+ return true
+ case <-cancel:
+ return false
+ }
+ }
+ return false
+}
+
+// DoRetryForDuration returns a SendDecorator that retries the request until the total time is equal
+// to or greater than the specified duration, exponentially backing off between requests using the
+// supplied backoff time.Duration (which may be zero). Retrying may be canceled by closing the
+// optional channel on the http.Request.
+func DoRetryForDuration(d time.Duration, backoff time.Duration) SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (resp *http.Response, err error) {
+ rr := NewRetriableRequest(r)
+ end := time.Now().Add(d)
+ for attempt := 0; time.Now().Before(end); attempt++ {
+ err = rr.Prepare()
+ if err != nil {
+ return resp, err
+ }
+ resp, err = s.Do(rr.Request())
+ if err == nil {
+ return resp, err
+ }
+ if !DelayForBackoff(backoff, attempt, r.Context().Done()) {
+ return nil, r.Context().Err()
+ }
+ }
+ return resp, err
+ })
+ }
+}
+
+// WithLogging returns a SendDecorator that implements simple before and after logging of the
+// request.
+func WithLogging(logger *log.Logger) SendDecorator {
+ return func(s Sender) Sender {
+ return SenderFunc(func(r *http.Request) (*http.Response, error) {
+ logger.Printf("Sending %s %s", r.Method, r.URL)
+ resp, err := s.Do(r)
+ if err != nil {
+ logger.Printf("%s %s received error '%v'", r.Method, r.URL, err)
+ } else {
+ logger.Printf("%s %s received %s", r.Method, r.URL, resp.Status)
+ }
+ return resp, err
+ })
+ }
+}
+
+// DelayForBackoff invokes time.After for the supplied backoff duration raised to the power of
+// passed attempt (i.e., an exponential backoff delay). Backoff duration is in seconds and can set
+// to zero for no delay. The delay may be canceled by closing the passed channel. If terminated early,
+// returns false.
+// Note: Passing attempt 1 will result in doubling "backoff" duration. Treat this as a zero-based attempt
+// count.
+func DelayForBackoff(backoff time.Duration, attempt int, cancel <-chan struct{}) bool {
+ select {
+ case <-time.After(time.Duration(backoff.Seconds()*math.Pow(2, float64(attempt))) * time.Second):
+ return true
+ case <-cancel:
+ return false
+ }
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/to/convert.go b/vendor/github.com/Azure/go-autorest/autorest/to/convert.go
new file mode 100644
index 0000000000..fdda2ce1aa
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/to/convert.go
@@ -0,0 +1,147 @@
+/*
+Package to provides helpers to ease working with pointer values of marshalled structures.
+*/
+package to
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+// String returns a string value for the passed string pointer. It returns the empty string if the
+// pointer is nil.
+func String(s *string) string {
+ if s != nil {
+ return *s
+ }
+ return ""
+}
+
+// StringPtr returns a pointer to the passed string.
+func StringPtr(s string) *string {
+ return &s
+}
+
+// StringSlice returns a string slice value for the passed string slice pointer. It returns a nil
+// slice if the pointer is nil.
+func StringSlice(s *[]string) []string {
+ if s != nil {
+ return *s
+ }
+ return nil
+}
+
+// StringSlicePtr returns a pointer to the passed string slice.
+func StringSlicePtr(s []string) *[]string {
+ return &s
+}
+
+// StringMap returns a map of strings built from the map of string pointers. The empty string is
+// used for nil pointers.
+func StringMap(msp map[string]*string) map[string]string {
+ ms := make(map[string]string, len(msp))
+ for k, sp := range msp {
+ if sp != nil {
+ ms[k] = *sp
+ } else {
+ ms[k] = ""
+ }
+ }
+ return ms
+}
+
+// StringMapPtr returns a pointer to a map of string pointers built from the passed map of strings.
+func StringMapPtr(ms map[string]string) *map[string]*string {
+ msp := make(map[string]*string, len(ms))
+ for k, s := range ms {
+ msp[k] = StringPtr(s)
+ }
+ return &msp
+}
+
+// Bool returns a bool value for the passed bool pointer. It returns false if the pointer is nil.
+func Bool(b *bool) bool {
+ if b != nil {
+ return *b
+ }
+ return false
+}
+
+// BoolPtr returns a pointer to the passed bool.
+func BoolPtr(b bool) *bool {
+ return &b
+}
+
+// Int returns an int value for the passed int pointer. It returns 0 if the pointer is nil.
+func Int(i *int) int {
+ if i != nil {
+ return *i
+ }
+ return 0
+}
+
+// IntPtr returns a pointer to the passed int.
+func IntPtr(i int) *int {
+ return &i
+}
+
+// Int32 returns an int value for the passed int pointer. It returns 0 if the pointer is nil.
+func Int32(i *int32) int32 {
+ if i != nil {
+ return *i
+ }
+ return 0
+}
+
+// Int32Ptr returns a pointer to the passed int32.
+func Int32Ptr(i int32) *int32 {
+ return &i
+}
+
+// Int64 returns an int value for the passed int pointer. It returns 0 if the pointer is nil.
+func Int64(i *int64) int64 {
+ if i != nil {
+ return *i
+ }
+ return 0
+}
+
+// Int64Ptr returns a pointer to the passed int64.
+func Int64Ptr(i int64) *int64 {
+ return &i
+}
+
+// Float32 returns an int value for the passed int pointer. It returns 0.0 if the pointer is nil.
+func Float32(i *float32) float32 {
+ if i != nil {
+ return *i
+ }
+ return 0.0
+}
+
+// Float32Ptr returns a pointer to the passed float32.
+func Float32Ptr(i float32) *float32 {
+ return &i
+}
+
+// Float64 returns an int value for the passed int pointer. It returns 0.0 if the pointer is nil.
+func Float64(i *float64) float64 {
+ if i != nil {
+ return *i
+ }
+ return 0.0
+}
+
+// Float64Ptr returns a pointer to the passed float64.
+func Float64Ptr(i float64) *float64 {
+ return &i
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/utility.go b/vendor/github.com/Azure/go-autorest/autorest/utility.go
new file mode 100644
index 0000000000..08cf11c118
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/utility.go
@@ -0,0 +1,228 @@
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "encoding/json"
+ "encoding/xml"
+ "fmt"
+ "io"
+ "net"
+ "net/http"
+ "net/url"
+ "reflect"
+ "strings"
+
+ "github.com/Azure/go-autorest/autorest/adal"
+)
+
+// EncodedAs is a series of constants specifying various data encodings
+type EncodedAs string
+
+const (
+ // EncodedAsJSON states that data is encoded as JSON
+ EncodedAsJSON EncodedAs = "JSON"
+
+ // EncodedAsXML states that data is encoded as Xml
+ EncodedAsXML EncodedAs = "XML"
+)
+
+// Decoder defines the decoding method json.Decoder and xml.Decoder share
+type Decoder interface {
+ Decode(v interface{}) error
+}
+
+// NewDecoder creates a new decoder appropriate to the passed encoding.
+// encodedAs specifies the type of encoding and r supplies the io.Reader containing the
+// encoded data.
+func NewDecoder(encodedAs EncodedAs, r io.Reader) Decoder {
+ if encodedAs == EncodedAsJSON {
+ return json.NewDecoder(r)
+ } else if encodedAs == EncodedAsXML {
+ return xml.NewDecoder(r)
+ }
+ return nil
+}
+
+// CopyAndDecode decodes the data from the passed io.Reader while making a copy. Having a copy
+// is especially useful if there is a chance the data will fail to decode.
+// encodedAs specifies the expected encoding, r provides the io.Reader to the data, and v
+// is the decoding destination.
+func CopyAndDecode(encodedAs EncodedAs, r io.Reader, v interface{}) (bytes.Buffer, error) {
+ b := bytes.Buffer{}
+ return b, NewDecoder(encodedAs, io.TeeReader(r, &b)).Decode(v)
+}
+
+// TeeReadCloser returns a ReadCloser that writes to w what it reads from rc.
+// It utilizes io.TeeReader to copy the data read and has the same behavior when reading.
+// Further, when it is closed, it ensures that rc is closed as well.
+func TeeReadCloser(rc io.ReadCloser, w io.Writer) io.ReadCloser {
+ return &teeReadCloser{rc, io.TeeReader(rc, w)}
+}
+
+type teeReadCloser struct {
+ rc io.ReadCloser
+ r io.Reader
+}
+
+func (t *teeReadCloser) Read(p []byte) (int, error) {
+ return t.r.Read(p)
+}
+
+func (t *teeReadCloser) Close() error {
+ return t.rc.Close()
+}
+
+func containsInt(ints []int, n int) bool {
+ for _, i := range ints {
+ if i == n {
+ return true
+ }
+ }
+ return false
+}
+
+func escapeValueStrings(m map[string]string) map[string]string {
+ for key, value := range m {
+ m[key] = url.QueryEscape(value)
+ }
+ return m
+}
+
+func ensureValueStrings(mapOfInterface map[string]interface{}) map[string]string {
+ mapOfStrings := make(map[string]string)
+ for key, value := range mapOfInterface {
+ mapOfStrings[key] = ensureValueString(value)
+ }
+ return mapOfStrings
+}
+
+func ensureValueString(value interface{}) string {
+ if value == nil {
+ return ""
+ }
+ switch v := value.(type) {
+ case string:
+ return v
+ case []byte:
+ return string(v)
+ default:
+ return fmt.Sprintf("%v", v)
+ }
+}
+
+// MapToValues method converts map[string]interface{} to url.Values.
+func MapToValues(m map[string]interface{}) url.Values {
+ v := url.Values{}
+ for key, value := range m {
+ x := reflect.ValueOf(value)
+ if x.Kind() == reflect.Array || x.Kind() == reflect.Slice {
+ for i := 0; i < x.Len(); i++ {
+ v.Add(key, ensureValueString(x.Index(i)))
+ }
+ } else {
+ v.Add(key, ensureValueString(value))
+ }
+ }
+ return v
+}
+
+// AsStringSlice method converts interface{} to []string. This expects a
+//that the parameter passed to be a slice or array of a type that has the underlying
+//type a string.
+func AsStringSlice(s interface{}) ([]string, error) {
+ v := reflect.ValueOf(s)
+ if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+ return nil, NewError("autorest", "AsStringSlice", "the value's type is not an array.")
+ }
+ stringSlice := make([]string, 0, v.Len())
+
+ for i := 0; i < v.Len(); i++ {
+ stringSlice = append(stringSlice, v.Index(i).String())
+ }
+ return stringSlice, nil
+}
+
+// String method converts interface v to string. If interface is a list, it
+// joins list elements using the separator. Note that only sep[0] will be used for
+// joining if any separator is specified.
+func String(v interface{}, sep ...string) string {
+ if len(sep) == 0 {
+ return ensureValueString(v)
+ }
+ stringSlice, ok := v.([]string)
+ if ok == false {
+ var err error
+ stringSlice, err = AsStringSlice(v)
+ if err != nil {
+ panic(fmt.Sprintf("autorest: Couldn't convert value to a string %s.", err))
+ }
+ }
+ return ensureValueString(strings.Join(stringSlice, sep[0]))
+}
+
+// Encode method encodes url path and query parameters.
+func Encode(location string, v interface{}, sep ...string) string {
+ s := String(v, sep...)
+ switch strings.ToLower(location) {
+ case "path":
+ return pathEscape(s)
+ case "query":
+ return queryEscape(s)
+ default:
+ return s
+ }
+}
+
+func pathEscape(s string) string {
+ return strings.Replace(url.QueryEscape(s), "+", "%20", -1)
+}
+
+func queryEscape(s string) string {
+ return url.QueryEscape(s)
+}
+
+// ChangeToGet turns the specified http.Request into a GET (it assumes it wasn't).
+// This is mainly useful for long-running operations that use the Azure-AsyncOperation
+// header, so we change the initial PUT into a GET to retrieve the final result.
+func ChangeToGet(req *http.Request) *http.Request {
+ req.Method = "GET"
+ req.Body = nil
+ req.ContentLength = 0
+ req.Header.Del("Content-Length")
+ return req
+}
+
+// IsTokenRefreshError returns true if the specified error implements the TokenRefreshError
+// interface. If err is a DetailedError it will walk the chain of Original errors.
+func IsTokenRefreshError(err error) bool {
+ if _, ok := err.(adal.TokenRefreshError); ok {
+ return true
+ }
+ if de, ok := err.(DetailedError); ok {
+ return IsTokenRefreshError(de.Original)
+ }
+ return false
+}
+
+// IsTemporaryNetworkError returns true if the specified error is a temporary network error or false
+// if it's not. If the error doesn't implement the net.Error interface the return value is true.
+func IsTemporaryNetworkError(err error) bool {
+ if netErr, ok := err.(net.Error); !ok || (ok && netErr.Temporary()) {
+ return true
+ }
+ return false
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/validation/error.go b/vendor/github.com/Azure/go-autorest/autorest/validation/error.go
new file mode 100644
index 0000000000..fed156dbf6
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/validation/error.go
@@ -0,0 +1,48 @@
+package validation
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "fmt"
+)
+
+// Error is the type that's returned when the validation of an APIs arguments constraints fails.
+type Error struct {
+ // PackageType is the package type of the object emitting the error. For types, the value
+ // matches that produced the the '%T' format specifier of the fmt package. For other elements,
+ // such as functions, it is just the package name (e.g., "autorest").
+ PackageType string
+
+ // Method is the name of the method raising the error.
+ Method string
+
+ // Message is the error message.
+ Message string
+}
+
+// Error returns a string containing the details of the validation failure.
+func (e Error) Error() string {
+ return fmt.Sprintf("%s#%s: Invalid input: %s", e.PackageType, e.Method, e.Message)
+}
+
+// NewError creates a new Error object with the specified parameters.
+// message is treated as a format string to which the optional args apply.
+func NewError(packageType string, method string, message string, args ...interface{}) Error {
+ return Error{
+ PackageType: packageType,
+ Method: method,
+ Message: fmt.Sprintf(message, args...),
+ }
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/validation/validation.go b/vendor/github.com/Azure/go-autorest/autorest/validation/validation.go
new file mode 100644
index 0000000000..ae987f8fae
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/validation/validation.go
@@ -0,0 +1,408 @@
+/*
+Package validation provides methods for validating parameter value using reflection.
+*/
+package validation
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "fmt"
+ "reflect"
+ "regexp"
+ "strings"
+)
+
+// Constraint stores constraint name, target field name
+// Rule and chain validations.
+type Constraint struct {
+
+ // Target field name for validation.
+ Target string
+
+ // Constraint name e.g. minLength, MaxLength, Pattern, etc.
+ Name string
+
+ // Rule for constraint e.g. greater than 10, less than 5 etc.
+ Rule interface{}
+
+ // Chain Validations for struct type
+ Chain []Constraint
+}
+
+// Validation stores parameter-wise validation.
+type Validation struct {
+ TargetValue interface{}
+ Constraints []Constraint
+}
+
+// Constraint list
+const (
+ Empty = "Empty"
+ Null = "Null"
+ ReadOnly = "ReadOnly"
+ Pattern = "Pattern"
+ MaxLength = "MaxLength"
+ MinLength = "MinLength"
+ MaxItems = "MaxItems"
+ MinItems = "MinItems"
+ MultipleOf = "MultipleOf"
+ UniqueItems = "UniqueItems"
+ InclusiveMaximum = "InclusiveMaximum"
+ ExclusiveMaximum = "ExclusiveMaximum"
+ ExclusiveMinimum = "ExclusiveMinimum"
+ InclusiveMinimum = "InclusiveMinimum"
+)
+
+// Validate method validates constraints on parameter
+// passed in validation array.
+func Validate(m []Validation) error {
+ for _, item := range m {
+ v := reflect.ValueOf(item.TargetValue)
+ for _, constraint := range item.Constraints {
+ var err error
+ switch v.Kind() {
+ case reflect.Ptr:
+ err = validatePtr(v, constraint)
+ case reflect.String:
+ err = validateString(v, constraint)
+ case reflect.Struct:
+ err = validateStruct(v, constraint)
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ err = validateInt(v, constraint)
+ case reflect.Float32, reflect.Float64:
+ err = validateFloat(v, constraint)
+ case reflect.Array, reflect.Slice, reflect.Map:
+ err = validateArrayMap(v, constraint)
+ default:
+ err = createError(v, constraint, fmt.Sprintf("unknown type %v", v.Kind()))
+ }
+
+ if err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+func validateStruct(x reflect.Value, v Constraint, name ...string) error {
+ //Get field name from target name which is in format a.b.c
+ s := strings.Split(v.Target, ".")
+ f := x.FieldByName(s[len(s)-1])
+ if isZero(f) {
+ return createError(x, v, fmt.Sprintf("field %q doesn't exist", v.Target))
+ }
+
+ return Validate([]Validation{
+ {
+ TargetValue: getInterfaceValue(f),
+ Constraints: []Constraint{v},
+ },
+ })
+}
+
+func validatePtr(x reflect.Value, v Constraint) error {
+ if v.Name == ReadOnly {
+ if !x.IsNil() {
+ return createError(x.Elem(), v, "readonly parameter; must send as nil or empty in request")
+ }
+ return nil
+ }
+ if x.IsNil() {
+ return checkNil(x, v)
+ }
+ if v.Chain != nil {
+ return Validate([]Validation{
+ {
+ TargetValue: getInterfaceValue(x.Elem()),
+ Constraints: v.Chain,
+ },
+ })
+ }
+ return nil
+}
+
+func validateInt(x reflect.Value, v Constraint) error {
+ i := x.Int()
+ r, ok := toInt64(v.Rule)
+ if !ok {
+ return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.Name, v.Rule))
+ }
+ switch v.Name {
+ case MultipleOf:
+ if i%r != 0 {
+ return createError(x, v, fmt.Sprintf("value must be a multiple of %v", r))
+ }
+ case ExclusiveMinimum:
+ if i <= r {
+ return createError(x, v, fmt.Sprintf("value must be greater than %v", r))
+ }
+ case ExclusiveMaximum:
+ if i >= r {
+ return createError(x, v, fmt.Sprintf("value must be less than %v", r))
+ }
+ case InclusiveMinimum:
+ if i < r {
+ return createError(x, v, fmt.Sprintf("value must be greater than or equal to %v", r))
+ }
+ case InclusiveMaximum:
+ if i > r {
+ return createError(x, v, fmt.Sprintf("value must be less than or equal to %v", r))
+ }
+ default:
+ return createError(x, v, fmt.Sprintf("constraint %v is not applicable for type integer", v.Name))
+ }
+ return nil
+}
+
+func validateFloat(x reflect.Value, v Constraint) error {
+ f := x.Float()
+ r, ok := v.Rule.(float64)
+ if !ok {
+ return createError(x, v, fmt.Sprintf("rule must be float value for %v constraint; got: %v", v.Name, v.Rule))
+ }
+ switch v.Name {
+ case ExclusiveMinimum:
+ if f <= r {
+ return createError(x, v, fmt.Sprintf("value must be greater than %v", r))
+ }
+ case ExclusiveMaximum:
+ if f >= r {
+ return createError(x, v, fmt.Sprintf("value must be less than %v", r))
+ }
+ case InclusiveMinimum:
+ if f < r {
+ return createError(x, v, fmt.Sprintf("value must be greater than or equal to %v", r))
+ }
+ case InclusiveMaximum:
+ if f > r {
+ return createError(x, v, fmt.Sprintf("value must be less than or equal to %v", r))
+ }
+ default:
+ return createError(x, v, fmt.Sprintf("constraint %s is not applicable for type float", v.Name))
+ }
+ return nil
+}
+
+func validateString(x reflect.Value, v Constraint) error {
+ s := x.String()
+ switch v.Name {
+ case Empty:
+ if len(s) == 0 {
+ return checkEmpty(x, v)
+ }
+ case Pattern:
+ reg, err := regexp.Compile(v.Rule.(string))
+ if err != nil {
+ return createError(x, v, err.Error())
+ }
+ if !reg.MatchString(s) {
+ return createError(x, v, fmt.Sprintf("value doesn't match pattern %v", v.Rule))
+ }
+ case MaxLength:
+ if _, ok := v.Rule.(int); !ok {
+ return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.Name, v.Rule))
+ }
+ if len(s) > v.Rule.(int) {
+ return createError(x, v, fmt.Sprintf("value length must be less than or equal to %v", v.Rule))
+ }
+ case MinLength:
+ if _, ok := v.Rule.(int); !ok {
+ return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.Name, v.Rule))
+ }
+ if len(s) < v.Rule.(int) {
+ return createError(x, v, fmt.Sprintf("value length must be greater than or equal to %v", v.Rule))
+ }
+ case ReadOnly:
+ if len(s) > 0 {
+ return createError(reflect.ValueOf(s), v, "readonly parameter; must send as nil or empty in request")
+ }
+ default:
+ return createError(x, v, fmt.Sprintf("constraint %s is not applicable to string type", v.Name))
+ }
+
+ if v.Chain != nil {
+ return Validate([]Validation{
+ {
+ TargetValue: getInterfaceValue(x),
+ Constraints: v.Chain,
+ },
+ })
+ }
+ return nil
+}
+
+func validateArrayMap(x reflect.Value, v Constraint) error {
+ switch v.Name {
+ case Null:
+ if x.IsNil() {
+ return checkNil(x, v)
+ }
+ case Empty:
+ if x.IsNil() || x.Len() == 0 {
+ return checkEmpty(x, v)
+ }
+ case MaxItems:
+ if _, ok := v.Rule.(int); !ok {
+ return createError(x, v, fmt.Sprintf("rule must be integer for %v constraint; got: %v", v.Name, v.Rule))
+ }
+ if x.Len() > v.Rule.(int) {
+ return createError(x, v, fmt.Sprintf("maximum item limit is %v; got: %v", v.Rule, x.Len()))
+ }
+ case MinItems:
+ if _, ok := v.Rule.(int); !ok {
+ return createError(x, v, fmt.Sprintf("rule must be integer for %v constraint; got: %v", v.Name, v.Rule))
+ }
+ if x.Len() < v.Rule.(int) {
+ return createError(x, v, fmt.Sprintf("minimum item limit is %v; got: %v", v.Rule, x.Len()))
+ }
+ case UniqueItems:
+ if x.Kind() == reflect.Array || x.Kind() == reflect.Slice {
+ if !checkForUniqueInArray(x) {
+ return createError(x, v, fmt.Sprintf("all items in parameter %q must be unique; got:%v", v.Target, x))
+ }
+ } else if x.Kind() == reflect.Map {
+ if !checkForUniqueInMap(x) {
+ return createError(x, v, fmt.Sprintf("all items in parameter %q must be unique; got:%v", v.Target, x))
+ }
+ } else {
+ return createError(x, v, fmt.Sprintf("type must be array, slice or map for constraint %v; got: %v", v.Name, x.Kind()))
+ }
+ case ReadOnly:
+ if x.Len() != 0 {
+ return createError(x, v, "readonly parameter; must send as nil or empty in request")
+ }
+ case Pattern:
+ reg, err := regexp.Compile(v.Rule.(string))
+ if err != nil {
+ return createError(x, v, err.Error())
+ }
+ keys := x.MapKeys()
+ for _, k := range keys {
+ if !reg.MatchString(k.String()) {
+ return createError(k, v, fmt.Sprintf("map key doesn't match pattern %v", v.Rule))
+ }
+ }
+ default:
+ return createError(x, v, fmt.Sprintf("constraint %v is not applicable to array, slice and map type", v.Name))
+ }
+
+ if v.Chain != nil {
+ return Validate([]Validation{
+ {
+ TargetValue: getInterfaceValue(x),
+ Constraints: v.Chain,
+ },
+ })
+ }
+ return nil
+}
+
+func checkNil(x reflect.Value, v Constraint) error {
+ if _, ok := v.Rule.(bool); !ok {
+ return createError(x, v, fmt.Sprintf("rule must be bool value for %v constraint; got: %v", v.Name, v.Rule))
+ }
+ if v.Rule.(bool) {
+ return createError(x, v, "value can not be null; required parameter")
+ }
+ return nil
+}
+
+func checkEmpty(x reflect.Value, v Constraint) error {
+ if _, ok := v.Rule.(bool); !ok {
+ return createError(x, v, fmt.Sprintf("rule must be bool value for %v constraint; got: %v", v.Name, v.Rule))
+ }
+
+ if v.Rule.(bool) {
+ return createError(x, v, "value can not be null or empty; required parameter")
+ }
+ return nil
+}
+
+func checkForUniqueInArray(x reflect.Value) bool {
+ if x == reflect.Zero(reflect.TypeOf(x)) || x.Len() == 0 {
+ return false
+ }
+ arrOfInterface := make([]interface{}, x.Len())
+
+ for i := 0; i < x.Len(); i++ {
+ arrOfInterface[i] = x.Index(i).Interface()
+ }
+
+ m := make(map[interface{}]bool)
+ for _, val := range arrOfInterface {
+ if m[val] {
+ return false
+ }
+ m[val] = true
+ }
+ return true
+}
+
+func checkForUniqueInMap(x reflect.Value) bool {
+ if x == reflect.Zero(reflect.TypeOf(x)) || x.Len() == 0 {
+ return false
+ }
+ mapOfInterface := make(map[interface{}]interface{}, x.Len())
+
+ keys := x.MapKeys()
+ for _, k := range keys {
+ mapOfInterface[k.Interface()] = x.MapIndex(k).Interface()
+ }
+
+ m := make(map[interface{}]bool)
+ for _, val := range mapOfInterface {
+ if m[val] {
+ return false
+ }
+ m[val] = true
+ }
+ return true
+}
+
+func getInterfaceValue(x reflect.Value) interface{} {
+ if x.Kind() == reflect.Invalid {
+ return nil
+ }
+ return x.Interface()
+}
+
+func isZero(x interface{}) bool {
+ return x == reflect.Zero(reflect.TypeOf(x)).Interface()
+}
+
+func createError(x reflect.Value, v Constraint, err string) error {
+ return fmt.Errorf("autorest/validation: validation failed: parameter=%s constraint=%s value=%#v details: %s",
+ v.Target, v.Name, getInterfaceValue(x), err)
+}
+
+func toInt64(v interface{}) (int64, bool) {
+ if i64, ok := v.(int64); ok {
+ return i64, true
+ }
+ // older generators emit max constants as int, so if int64 fails fall back to int
+ if i32, ok := v.(int); ok {
+ return int64(i32), true
+ }
+ return 0, false
+}
+
+// NewErrorWithValidationError appends package type and method name in
+// validation error.
+//
+// Deprecated: Please use validation.NewError() instead.
+func NewErrorWithValidationError(err error, packageType, method string) error {
+ return NewError(packageType, method, err.Error())
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/version.go b/vendor/github.com/Azure/go-autorest/autorest/version.go
new file mode 100644
index 0000000000..6230b73961
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/version.go
@@ -0,0 +1,41 @@
+package autorest
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "fmt"
+ "runtime"
+)
+
+const number = "v11.5.0"
+
+var (
+ userAgent = fmt.Sprintf("Go/%s (%s-%s) go-autorest/%s",
+ runtime.Version(),
+ runtime.GOARCH,
+ runtime.GOOS,
+ number,
+ )
+)
+
+// UserAgent returns a string containing the Go version, system architecture and OS, and the go-autorest version.
+func UserAgent() string {
+ return userAgent
+}
+
+// Version returns the semantic version (see http://semver.org).
+func Version() string {
+ return number
+}
diff --git a/vendor/github.com/Azure/go-autorest/logger/logger.go b/vendor/github.com/Azure/go-autorest/logger/logger.go
new file mode 100644
index 0000000000..da09f394c5
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/logger/logger.go
@@ -0,0 +1,328 @@
+package logger
+
+// Copyright 2017 Microsoft Corporation
+//
+// 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.
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "os"
+ "strings"
+ "sync"
+ "time"
+)
+
+// LevelType tells a logger the minimum level to log. When code reports a log entry,
+// the LogLevel indicates the level of the log entry. The logger only records entries
+// whose level is at least the level it was told to log. See the Log* constants.
+// For example, if a logger is configured with LogError, then LogError, LogPanic,
+// and LogFatal entries will be logged; lower level entries are ignored.
+type LevelType uint32
+
+const (
+ // LogNone tells a logger not to log any entries passed to it.
+ LogNone LevelType = iota
+
+ // LogFatal tells a logger to log all LogFatal entries passed to it.
+ LogFatal
+
+ // LogPanic tells a logger to log all LogPanic and LogFatal entries passed to it.
+ LogPanic
+
+ // LogError tells a logger to log all LogError, LogPanic and LogFatal entries passed to it.
+ LogError
+
+ // LogWarning tells a logger to log all LogWarning, LogError, LogPanic and LogFatal entries passed to it.
+ LogWarning
+
+ // LogInfo tells a logger to log all LogInfo, LogWarning, LogError, LogPanic and LogFatal entries passed to it.
+ LogInfo
+
+ // LogDebug tells a logger to log all LogDebug, LogInfo, LogWarning, LogError, LogPanic and LogFatal entries passed to it.
+ LogDebug
+)
+
+const (
+ logNone = "NONE"
+ logFatal = "FATAL"
+ logPanic = "PANIC"
+ logError = "ERROR"
+ logWarning = "WARNING"
+ logInfo = "INFO"
+ logDebug = "DEBUG"
+ logUnknown = "UNKNOWN"
+)
+
+// ParseLevel converts the specified string into the corresponding LevelType.
+func ParseLevel(s string) (lt LevelType, err error) {
+ switch strings.ToUpper(s) {
+ case logFatal:
+ lt = LogFatal
+ case logPanic:
+ lt = LogPanic
+ case logError:
+ lt = LogError
+ case logWarning:
+ lt = LogWarning
+ case logInfo:
+ lt = LogInfo
+ case logDebug:
+ lt = LogDebug
+ default:
+ err = fmt.Errorf("bad log level '%s'", s)
+ }
+ return
+}
+
+// String implements the stringer interface for LevelType.
+func (lt LevelType) String() string {
+ switch lt {
+ case LogNone:
+ return logNone
+ case LogFatal:
+ return logFatal
+ case LogPanic:
+ return logPanic
+ case LogError:
+ return logError
+ case LogWarning:
+ return logWarning
+ case LogInfo:
+ return logInfo
+ case LogDebug:
+ return logDebug
+ default:
+ return logUnknown
+ }
+}
+
+// Filter defines functions for filtering HTTP request/response content.
+type Filter struct {
+ // URL returns a potentially modified string representation of a request URL.
+ URL func(u *url.URL) string
+
+ // Header returns a potentially modified set of values for the specified key.
+ // To completely exclude the header key/values return false.
+ Header func(key string, val []string) (bool, []string)
+
+ // Body returns a potentially modified request/response body.
+ Body func(b []byte) []byte
+}
+
+func (f Filter) processURL(u *url.URL) string {
+ if f.URL == nil {
+ return u.String()
+ }
+ return f.URL(u)
+}
+
+func (f Filter) processHeader(k string, val []string) (bool, []string) {
+ if f.Header == nil {
+ return true, val
+ }
+ return f.Header(k, val)
+}
+
+func (f Filter) processBody(b []byte) []byte {
+ if f.Body == nil {
+ return b
+ }
+ return f.Body(b)
+}
+
+// Writer defines methods for writing to a logging facility.
+type Writer interface {
+ // Writeln writes the specified message with the standard log entry header and new-line character.
+ Writeln(level LevelType, message string)
+
+ // Writef writes the specified format specifier with the standard log entry header and no new-line character.
+ Writef(level LevelType, format string, a ...interface{})
+
+ // WriteRequest writes the specified HTTP request to the logger if the log level is greater than
+ // or equal to LogInfo. The request body, if set, is logged at level LogDebug or higher.
+ // Custom filters can be specified to exclude URL, header, and/or body content from the log.
+ // By default no request content is excluded.
+ WriteRequest(req *http.Request, filter Filter)
+
+ // WriteResponse writes the specified HTTP response to the logger if the log level is greater than
+ // or equal to LogInfo. The response body, if set, is logged at level LogDebug or higher.
+ // Custom filters can be specified to exclude URL, header, and/or body content from the log.
+ // By default no response content is excluded.
+ WriteResponse(resp *http.Response, filter Filter)
+}
+
+// Instance is the default log writer initialized during package init.
+// This can be replaced with a custom implementation as required.
+var Instance Writer
+
+// default log level
+var logLevel = LogNone
+
+// Level returns the value specified in AZURE_GO_AUTOREST_LOG_LEVEL.
+// If no value was specified the default value is LogNone.
+// Custom loggers can call this to retrieve the configured log level.
+func Level() LevelType {
+ return logLevel
+}
+
+func init() {
+ // separated for testing purposes
+ initDefaultLogger()
+}
+
+func initDefaultLogger() {
+ // init with nilLogger so callers don't have to do a nil check on Default
+ Instance = nilLogger{}
+ llStr := strings.ToLower(os.Getenv("AZURE_GO_SDK_LOG_LEVEL"))
+ if llStr == "" {
+ return
+ }
+ var err error
+ logLevel, err = ParseLevel(llStr)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "go-autorest: failed to parse log level: %s\n", err.Error())
+ return
+ }
+ if logLevel == LogNone {
+ return
+ }
+ // default to stderr
+ dest := os.Stderr
+ lfStr := os.Getenv("AZURE_GO_SDK_LOG_FILE")
+ if strings.EqualFold(lfStr, "stdout") {
+ dest = os.Stdout
+ } else if lfStr != "" {
+ lf, err := os.Create(lfStr)
+ if err == nil {
+ dest = lf
+ } else {
+ fmt.Fprintf(os.Stderr, "go-autorest: failed to create log file, using stderr: %s\n", err.Error())
+ }
+ }
+ Instance = fileLogger{
+ logLevel: logLevel,
+ mu: &sync.Mutex{},
+ logFile: dest,
+ }
+}
+
+// the nil logger does nothing
+type nilLogger struct{}
+
+func (nilLogger) Writeln(LevelType, string) {}
+
+func (nilLogger) Writef(LevelType, string, ...interface{}) {}
+
+func (nilLogger) WriteRequest(*http.Request, Filter) {}
+
+func (nilLogger) WriteResponse(*http.Response, Filter) {}
+
+// A File is used instead of a Logger so the stream can be flushed after every write.
+type fileLogger struct {
+ logLevel LevelType
+ mu *sync.Mutex // for synchronizing writes to logFile
+ logFile *os.File
+}
+
+func (fl fileLogger) Writeln(level LevelType, message string) {
+ fl.Writef(level, "%s\n", message)
+}
+
+func (fl fileLogger) Writef(level LevelType, format string, a ...interface{}) {
+ if fl.logLevel >= level {
+ fl.mu.Lock()
+ defer fl.mu.Unlock()
+ fmt.Fprintf(fl.logFile, "%s %s", entryHeader(level), fmt.Sprintf(format, a...))
+ fl.logFile.Sync()
+ }
+}
+
+func (fl fileLogger) WriteRequest(req *http.Request, filter Filter) {
+ if req == nil || fl.logLevel < LogInfo {
+ return
+ }
+ b := &bytes.Buffer{}
+ fmt.Fprintf(b, "%s REQUEST: %s %s\n", entryHeader(LogInfo), req.Method, filter.processURL(req.URL))
+ // dump headers
+ for k, v := range req.Header {
+ if ok, mv := filter.processHeader(k, v); ok {
+ fmt.Fprintf(b, "%s: %s\n", k, strings.Join(mv, ","))
+ }
+ }
+ if fl.shouldLogBody(req.Header, req.Body) {
+ // dump body
+ body, err := ioutil.ReadAll(req.Body)
+ if err == nil {
+ fmt.Fprintln(b, string(filter.processBody(body)))
+ if nc, ok := req.Body.(io.Seeker); ok {
+ // rewind to the beginning
+ nc.Seek(0, io.SeekStart)
+ } else {
+ // recreate the body
+ req.Body = ioutil.NopCloser(bytes.NewReader(body))
+ }
+ } else {
+ fmt.Fprintf(b, "failed to read body: %v\n", err)
+ }
+ }
+ fl.mu.Lock()
+ defer fl.mu.Unlock()
+ fmt.Fprint(fl.logFile, b.String())
+ fl.logFile.Sync()
+}
+
+func (fl fileLogger) WriteResponse(resp *http.Response, filter Filter) {
+ if resp == nil || fl.logLevel < LogInfo {
+ return
+ }
+ b := &bytes.Buffer{}
+ fmt.Fprintf(b, "%s RESPONSE: %d %s\n", entryHeader(LogInfo), resp.StatusCode, filter.processURL(resp.Request.URL))
+ // dump headers
+ for k, v := range resp.Header {
+ if ok, mv := filter.processHeader(k, v); ok {
+ fmt.Fprintf(b, "%s: %s\n", k, strings.Join(mv, ","))
+ }
+ }
+ if fl.shouldLogBody(resp.Header, resp.Body) {
+ // dump body
+ defer resp.Body.Close()
+ body, err := ioutil.ReadAll(resp.Body)
+ if err == nil {
+ fmt.Fprintln(b, string(filter.processBody(body)))
+ resp.Body = ioutil.NopCloser(bytes.NewReader(body))
+ } else {
+ fmt.Fprintf(b, "failed to read body: %v\n", err)
+ }
+ }
+ fl.mu.Lock()
+ defer fl.mu.Unlock()
+ fmt.Fprint(fl.logFile, b.String())
+ fl.logFile.Sync()
+}
+
+// returns true if the provided body should be included in the log
+func (fl fileLogger) shouldLogBody(header http.Header, body io.ReadCloser) bool {
+ ct := header.Get("Content-Type")
+ return fl.logLevel >= LogDebug && body != nil && !strings.Contains(ct, "application/octet-stream")
+}
+
+// creates standard header for log entries, it contains a timestamp and the log level
+func entryHeader(level LevelType) string {
+ // this format provides a fixed number of digits so the size of the timestamp is constant
+ return fmt.Sprintf("(%s) %s:", time.Now().Format("2006-01-02T15:04:05.0000000Z07:00"), level.String())
+}
diff --git a/vendor/github.com/Azure/go-autorest/tracing/tracing.go b/vendor/github.com/Azure/go-autorest/tracing/tracing.go
new file mode 100644
index 0000000000..cd61cb18b6
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/tracing/tracing.go
@@ -0,0 +1,190 @@
+package tracing
+
+// Copyright 2018 Microsoft Corporation
+//
+// 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.
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+ "os"
+
+ "contrib.go.opencensus.io/exporter/ocagent"
+ "go.opencensus.io/plugin/ochttp"
+ "go.opencensus.io/plugin/ochttp/propagation/tracecontext"
+ "go.opencensus.io/stats/view"
+ "go.opencensus.io/trace"
+)
+
+var (
+ // Transport is the default tracing RoundTripper. The custom options setter will control
+ // if traces are being emitted or not.
+ Transport = &ochttp.Transport{
+ Propagation: &tracecontext.HTTPFormat{},
+ GetStartOptions: getStartOptions,
+ }
+
+ // enabled is the flag for marking if tracing is enabled.
+ enabled = false
+
+ // Sampler is the tracing sampler. If tracing is disabled it will never sample. Otherwise
+ // it will be using the parent sampler or the default.
+ sampler = trace.NeverSample()
+
+ // Views for metric instrumentation.
+ views = map[string]*view.View{}
+
+ // the trace exporter
+ traceExporter trace.Exporter
+)
+
+func init() {
+ enableFromEnv()
+}
+
+func enableFromEnv() {
+ _, ok := os.LookupEnv("AZURE_SDK_TRACING_ENABLED")
+ _, legacyOk := os.LookupEnv("AZURE_SDK_TRACING_ENABELD")
+ if ok || legacyOk {
+ agentEndpoint, ok := os.LookupEnv("OCAGENT_TRACE_EXPORTER_ENDPOINT")
+
+ if ok {
+ EnableWithAIForwarding(agentEndpoint)
+ } else {
+ Enable()
+ }
+ }
+}
+
+// IsEnabled returns true if monitoring is enabled for the sdk.
+func IsEnabled() bool {
+ return enabled
+}
+
+// Enable will start instrumentation for metrics and traces.
+func Enable() error {
+ enabled = true
+ sampler = nil
+
+ err := initStats()
+ return err
+}
+
+// Disable will disable instrumentation for metrics and traces.
+func Disable() {
+ disableStats()
+ sampler = trace.NeverSample()
+ if traceExporter != nil {
+ trace.UnregisterExporter(traceExporter)
+ }
+ enabled = false
+}
+
+// EnableWithAIForwarding will start instrumentation and will connect to app insights forwarder
+// exporter making the metrics and traces available in app insights.
+func EnableWithAIForwarding(agentEndpoint string) (err error) {
+ err = Enable()
+ if err != nil {
+ return err
+ }
+
+ traceExporter, err := ocagent.NewExporter(ocagent.WithInsecure(), ocagent.WithAddress(agentEndpoint))
+ if err != nil {
+ return err
+ }
+ trace.RegisterExporter(traceExporter)
+ return
+}
+
+// getStartOptions is the custom options setter for the ochttp package.
+func getStartOptions(*http.Request) trace.StartOptions {
+ return trace.StartOptions{
+ Sampler: sampler,
+ }
+}
+
+// initStats registers the views for the http metrics
+func initStats() (err error) {
+ clientViews := []*view.View{
+ ochttp.ClientCompletedCount,
+ ochttp.ClientRoundtripLatencyDistribution,
+ ochttp.ClientReceivedBytesDistribution,
+ ochttp.ClientSentBytesDistribution,
+ }
+ for _, cv := range clientViews {
+ vn := fmt.Sprintf("Azure/go-autorest/tracing-%s", cv.Name)
+ views[vn] = cv.WithName(vn)
+ err = view.Register(views[vn])
+ if err != nil {
+ return err
+ }
+ }
+ return
+}
+
+// disableStats will unregister the previously registered metrics
+func disableStats() {
+ for _, v := range views {
+ view.Unregister(v)
+ }
+}
+
+// StartSpan starts a trace span
+func StartSpan(ctx context.Context, name string) context.Context {
+ ctx, _ = trace.StartSpan(ctx, name, trace.WithSampler(sampler))
+ return ctx
+}
+
+// EndSpan ends a previously started span stored in the context
+func EndSpan(ctx context.Context, httpStatusCode int, err error) {
+ span := trace.FromContext(ctx)
+
+ if span == nil {
+ return
+ }
+
+ if err != nil {
+ span.SetStatus(trace.Status{Message: err.Error(), Code: toTraceStatusCode(httpStatusCode)})
+ }
+ span.End()
+}
+
+// toTraceStatusCode converts HTTP Codes to OpenCensus codes as defined
+// at https://github.com/census-instrumentation/opencensus-specs/blob/master/trace/HTTP.md#status
+func toTraceStatusCode(httpStatusCode int) int32 {
+ switch {
+ case http.StatusOK <= httpStatusCode && httpStatusCode < http.StatusBadRequest:
+ return trace.StatusCodeOK
+ case httpStatusCode == http.StatusBadRequest:
+ return trace.StatusCodeInvalidArgument
+ case httpStatusCode == http.StatusUnauthorized: // 401 is actually unauthenticated.
+ return trace.StatusCodeUnauthenticated
+ case httpStatusCode == http.StatusForbidden:
+ return trace.StatusCodePermissionDenied
+ case httpStatusCode == http.StatusNotFound:
+ return trace.StatusCodeNotFound
+ case httpStatusCode == http.StatusTooManyRequests:
+ return trace.StatusCodeResourceExhausted
+ case httpStatusCode == 499:
+ return trace.StatusCodeCancelled
+ case httpStatusCode == http.StatusNotImplemented:
+ return trace.StatusCodeUnimplemented
+ case httpStatusCode == http.StatusServiceUnavailable:
+ return trace.StatusCodeUnavailable
+ case httpStatusCode == http.StatusGatewayTimeout:
+ return trace.StatusCodeDeadlineExceeded
+ default:
+ return trace.StatusCodeUnknown
+ }
+}
diff --git a/vendor/github.com/census-instrumentation/opencensus-proto/AUTHORS b/vendor/github.com/census-instrumentation/opencensus-proto/AUTHORS
new file mode 100644
index 0000000000..e068e731ea
--- /dev/null
+++ b/vendor/github.com/census-instrumentation/opencensus-proto/AUTHORS
@@ -0,0 +1 @@
+Google Inc.
\ No newline at end of file
diff --git a/vendor/github.com/census-instrumentation/opencensus-proto/LICENSE b/vendor/github.com/census-instrumentation/opencensus-proto/LICENSE
new file mode 100644
index 0000000000..d645695673
--- /dev/null
+++ b/vendor/github.com/census-instrumentation/opencensus-proto/LICENSE
@@ -0,0 +1,202 @@
+
+ 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.
diff --git a/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/agent/common/v1/common.pb.go b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/agent/common/v1/common.pb.go
new file mode 100644
index 0000000000..2f12e428ed
--- /dev/null
+++ b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/agent/common/v1/common.pb.go
@@ -0,0 +1,356 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: opencensus/proto/agent/common/v1/common.proto
+
+package v1
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ timestamp "github.com/golang/protobuf/ptypes/timestamp"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type LibraryInfo_Language int32
+
+const (
+ LibraryInfo_LANGUAGE_UNSPECIFIED LibraryInfo_Language = 0
+ LibraryInfo_CPP LibraryInfo_Language = 1
+ LibraryInfo_C_SHARP LibraryInfo_Language = 2
+ LibraryInfo_ERLANG LibraryInfo_Language = 3
+ LibraryInfo_GO_LANG LibraryInfo_Language = 4
+ LibraryInfo_JAVA LibraryInfo_Language = 5
+ LibraryInfo_NODE_JS LibraryInfo_Language = 6
+ LibraryInfo_PHP LibraryInfo_Language = 7
+ LibraryInfo_PYTHON LibraryInfo_Language = 8
+ LibraryInfo_RUBY LibraryInfo_Language = 9
+)
+
+var LibraryInfo_Language_name = map[int32]string{
+ 0: "LANGUAGE_UNSPECIFIED",
+ 1: "CPP",
+ 2: "C_SHARP",
+ 3: "ERLANG",
+ 4: "GO_LANG",
+ 5: "JAVA",
+ 6: "NODE_JS",
+ 7: "PHP",
+ 8: "PYTHON",
+ 9: "RUBY",
+}
+
+var LibraryInfo_Language_value = map[string]int32{
+ "LANGUAGE_UNSPECIFIED": 0,
+ "CPP": 1,
+ "C_SHARP": 2,
+ "ERLANG": 3,
+ "GO_LANG": 4,
+ "JAVA": 5,
+ "NODE_JS": 6,
+ "PHP": 7,
+ "PYTHON": 8,
+ "RUBY": 9,
+}
+
+func (x LibraryInfo_Language) String() string {
+ return proto.EnumName(LibraryInfo_Language_name, int32(x))
+}
+
+func (LibraryInfo_Language) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_126c72ed8a252c84, []int{2, 0}
+}
+
+// Identifier metadata of the Node (Application instrumented with OpenCensus)
+// that connects to OpenCensus Agent.
+// In the future we plan to extend the identifier proto definition to support
+// additional information (e.g cloud id, etc.)
+type Node struct {
+ // Identifier that uniquely identifies a process within a VM/container.
+ Identifier *ProcessIdentifier `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
+ // Information on the OpenCensus Library that initiates the stream.
+ LibraryInfo *LibraryInfo `protobuf:"bytes,2,opt,name=library_info,json=libraryInfo,proto3" json:"library_info,omitempty"`
+ // Additional information on service.
+ ServiceInfo *ServiceInfo `protobuf:"bytes,3,opt,name=service_info,json=serviceInfo,proto3" json:"service_info,omitempty"`
+ // Additional attributes.
+ Attributes map[string]string `protobuf:"bytes,4,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Node) Reset() { *m = Node{} }
+func (m *Node) String() string { return proto.CompactTextString(m) }
+func (*Node) ProtoMessage() {}
+func (*Node) Descriptor() ([]byte, []int) {
+ return fileDescriptor_126c72ed8a252c84, []int{0}
+}
+
+func (m *Node) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Node.Unmarshal(m, b)
+}
+func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Node.Marshal(b, m, deterministic)
+}
+func (m *Node) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Node.Merge(m, src)
+}
+func (m *Node) XXX_Size() int {
+ return xxx_messageInfo_Node.Size(m)
+}
+func (m *Node) XXX_DiscardUnknown() {
+ xxx_messageInfo_Node.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Node proto.InternalMessageInfo
+
+func (m *Node) GetIdentifier() *ProcessIdentifier {
+ if m != nil {
+ return m.Identifier
+ }
+ return nil
+}
+
+func (m *Node) GetLibraryInfo() *LibraryInfo {
+ if m != nil {
+ return m.LibraryInfo
+ }
+ return nil
+}
+
+func (m *Node) GetServiceInfo() *ServiceInfo {
+ if m != nil {
+ return m.ServiceInfo
+ }
+ return nil
+}
+
+func (m *Node) GetAttributes() map[string]string {
+ if m != nil {
+ return m.Attributes
+ }
+ return nil
+}
+
+// Identifier that uniquely identifies a process within a VM/container.
+type ProcessIdentifier struct {
+ // The host name. Usually refers to the machine/container name.
+ // For example: os.Hostname() in Go, socket.gethostname() in Python.
+ HostName string `protobuf:"bytes,1,opt,name=host_name,json=hostName,proto3" json:"host_name,omitempty"`
+ // Process id.
+ Pid uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
+ // Start time of this ProcessIdentifier. Represented in epoch time.
+ StartTimestamp *timestamp.Timestamp `protobuf:"bytes,3,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ProcessIdentifier) Reset() { *m = ProcessIdentifier{} }
+func (m *ProcessIdentifier) String() string { return proto.CompactTextString(m) }
+func (*ProcessIdentifier) ProtoMessage() {}
+func (*ProcessIdentifier) Descriptor() ([]byte, []int) {
+ return fileDescriptor_126c72ed8a252c84, []int{1}
+}
+
+func (m *ProcessIdentifier) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ProcessIdentifier.Unmarshal(m, b)
+}
+func (m *ProcessIdentifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ProcessIdentifier.Marshal(b, m, deterministic)
+}
+func (m *ProcessIdentifier) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ProcessIdentifier.Merge(m, src)
+}
+func (m *ProcessIdentifier) XXX_Size() int {
+ return xxx_messageInfo_ProcessIdentifier.Size(m)
+}
+func (m *ProcessIdentifier) XXX_DiscardUnknown() {
+ xxx_messageInfo_ProcessIdentifier.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ProcessIdentifier proto.InternalMessageInfo
+
+func (m *ProcessIdentifier) GetHostName() string {
+ if m != nil {
+ return m.HostName
+ }
+ return ""
+}
+
+func (m *ProcessIdentifier) GetPid() uint32 {
+ if m != nil {
+ return m.Pid
+ }
+ return 0
+}
+
+func (m *ProcessIdentifier) GetStartTimestamp() *timestamp.Timestamp {
+ if m != nil {
+ return m.StartTimestamp
+ }
+ return nil
+}
+
+// Information on OpenCensus Library.
+type LibraryInfo struct {
+ // Language of OpenCensus Library.
+ Language LibraryInfo_Language `protobuf:"varint,1,opt,name=language,proto3,enum=opencensus.proto.agent.common.v1.LibraryInfo_Language" json:"language,omitempty"`
+ // Version of Agent exporter of Library.
+ ExporterVersion string `protobuf:"bytes,2,opt,name=exporter_version,json=exporterVersion,proto3" json:"exporter_version,omitempty"`
+ // Version of OpenCensus Library.
+ CoreLibraryVersion string `protobuf:"bytes,3,opt,name=core_library_version,json=coreLibraryVersion,proto3" json:"core_library_version,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *LibraryInfo) Reset() { *m = LibraryInfo{} }
+func (m *LibraryInfo) String() string { return proto.CompactTextString(m) }
+func (*LibraryInfo) ProtoMessage() {}
+func (*LibraryInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_126c72ed8a252c84, []int{2}
+}
+
+func (m *LibraryInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_LibraryInfo.Unmarshal(m, b)
+}
+func (m *LibraryInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_LibraryInfo.Marshal(b, m, deterministic)
+}
+func (m *LibraryInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_LibraryInfo.Merge(m, src)
+}
+func (m *LibraryInfo) XXX_Size() int {
+ return xxx_messageInfo_LibraryInfo.Size(m)
+}
+func (m *LibraryInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_LibraryInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LibraryInfo proto.InternalMessageInfo
+
+func (m *LibraryInfo) GetLanguage() LibraryInfo_Language {
+ if m != nil {
+ return m.Language
+ }
+ return LibraryInfo_LANGUAGE_UNSPECIFIED
+}
+
+func (m *LibraryInfo) GetExporterVersion() string {
+ if m != nil {
+ return m.ExporterVersion
+ }
+ return ""
+}
+
+func (m *LibraryInfo) GetCoreLibraryVersion() string {
+ if m != nil {
+ return m.CoreLibraryVersion
+ }
+ return ""
+}
+
+// Additional service information.
+type ServiceInfo struct {
+ // Name of the service.
+ Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServiceInfo) Reset() { *m = ServiceInfo{} }
+func (m *ServiceInfo) String() string { return proto.CompactTextString(m) }
+func (*ServiceInfo) ProtoMessage() {}
+func (*ServiceInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_126c72ed8a252c84, []int{3}
+}
+
+func (m *ServiceInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServiceInfo.Unmarshal(m, b)
+}
+func (m *ServiceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServiceInfo.Marshal(b, m, deterministic)
+}
+func (m *ServiceInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServiceInfo.Merge(m, src)
+}
+func (m *ServiceInfo) XXX_Size() int {
+ return xxx_messageInfo_ServiceInfo.Size(m)
+}
+func (m *ServiceInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServiceInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServiceInfo proto.InternalMessageInfo
+
+func (m *ServiceInfo) GetName() string {
+ if m != nil {
+ return m.Name
+ }
+ return ""
+}
+
+func init() {
+ proto.RegisterEnum("opencensus.proto.agent.common.v1.LibraryInfo_Language", LibraryInfo_Language_name, LibraryInfo_Language_value)
+ proto.RegisterType((*Node)(nil), "opencensus.proto.agent.common.v1.Node")
+ proto.RegisterMapType((map[string]string)(nil), "opencensus.proto.agent.common.v1.Node.AttributesEntry")
+ proto.RegisterType((*ProcessIdentifier)(nil), "opencensus.proto.agent.common.v1.ProcessIdentifier")
+ proto.RegisterType((*LibraryInfo)(nil), "opencensus.proto.agent.common.v1.LibraryInfo")
+ proto.RegisterType((*ServiceInfo)(nil), "opencensus.proto.agent.common.v1.ServiceInfo")
+}
+
+func init() {
+ proto.RegisterFile("opencensus/proto/agent/common/v1/common.proto", fileDescriptor_126c72ed8a252c84)
+}
+
+var fileDescriptor_126c72ed8a252c84 = []byte{
+ // 590 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0x4f, 0x4f, 0xdb, 0x3e,
+ 0x1c, 0xc6, 0x7f, 0x69, 0x0a, 0xb4, 0xdf, 0xfc, 0x06, 0x99, 0xc5, 0xa1, 0x62, 0x87, 0xb1, 0xee,
+ 0xc2, 0x0e, 0x4d, 0x06, 0x48, 0xd3, 0x34, 0x69, 0x87, 0x52, 0x3a, 0x28, 0x42, 0x25, 0x72, 0x01,
+ 0x89, 0x5d, 0xa2, 0xb4, 0xb8, 0xc1, 0x5a, 0x63, 0x57, 0xb6, 0x53, 0x8d, 0xd3, 0x8e, 0xd3, 0xde,
+ 0xc0, 0x5e, 0xd4, 0x5e, 0xd5, 0x64, 0x3b, 0x69, 0xa3, 0x71, 0x28, 0xb7, 0xef, 0x9f, 0xe7, 0xf9,
+ 0x38, 0x7a, 0x6c, 0x05, 0x3a, 0x7c, 0x4e, 0xd8, 0x84, 0x30, 0x99, 0xcb, 0x70, 0x2e, 0xb8, 0xe2,
+ 0x61, 0x92, 0x12, 0xa6, 0xc2, 0x09, 0xcf, 0x32, 0xce, 0xc2, 0xc5, 0x61, 0x51, 0x05, 0x66, 0x89,
+ 0xf6, 0x57, 0x72, 0x3b, 0x09, 0x8c, 0x3c, 0x28, 0x44, 0x8b, 0xc3, 0xbd, 0xd7, 0x29, 0xe7, 0xe9,
+ 0x8c, 0x58, 0xd8, 0x38, 0x9f, 0x86, 0x8a, 0x66, 0x44, 0xaa, 0x24, 0x9b, 0x5b, 0x43, 0xfb, 0xb7,
+ 0x0b, 0xf5, 0x21, 0xbf, 0x27, 0x68, 0x04, 0x40, 0xef, 0x09, 0x53, 0x74, 0x4a, 0x89, 0x68, 0x39,
+ 0xfb, 0xce, 0x81, 0x77, 0x74, 0x1c, 0xac, 0x3b, 0x20, 0x88, 0x04, 0x9f, 0x10, 0x29, 0x07, 0x4b,
+ 0x2b, 0xae, 0x60, 0x50, 0x04, 0xff, 0xcf, 0xe8, 0x58, 0x24, 0xe2, 0x31, 0xa6, 0x6c, 0xca, 0x5b,
+ 0x35, 0x83, 0xed, 0xac, 0xc7, 0x5e, 0x5a, 0xd7, 0x80, 0x4d, 0x39, 0xf6, 0x66, 0xab, 0x46, 0x13,
+ 0x25, 0x11, 0x0b, 0x3a, 0x21, 0x96, 0xe8, 0x3e, 0x97, 0x38, 0xb2, 0x2e, 0x4b, 0x94, 0xab, 0x06,
+ 0xdd, 0x02, 0x24, 0x4a, 0x09, 0x3a, 0xce, 0x15, 0x91, 0xad, 0xfa, 0xbe, 0x7b, 0xe0, 0x1d, 0x7d,
+ 0x58, 0xcf, 0xd3, 0xa1, 0x05, 0xdd, 0xa5, 0xb1, 0xcf, 0x94, 0x78, 0xc4, 0x15, 0xd2, 0xde, 0x67,
+ 0xd8, 0xf9, 0x67, 0x8d, 0x7c, 0x70, 0xbf, 0x91, 0x47, 0x13, 0x6e, 0x13, 0xeb, 0x12, 0xed, 0xc2,
+ 0xc6, 0x22, 0x99, 0xe5, 0xc4, 0x24, 0xd3, 0xc4, 0xb6, 0xf9, 0x54, 0xfb, 0xe8, 0xb4, 0x7f, 0x3a,
+ 0xf0, 0xf2, 0x49, 0xb8, 0xe8, 0x15, 0x34, 0x1f, 0xb8, 0x54, 0x31, 0x4b, 0x32, 0x52, 0x70, 0x1a,
+ 0x7a, 0x30, 0x4c, 0x32, 0xa2, 0xf1, 0x73, 0x7a, 0x6f, 0x50, 0x2f, 0xb0, 0x2e, 0x51, 0x0f, 0x76,
+ 0xa4, 0x4a, 0x84, 0x8a, 0x97, 0xd7, 0x5e, 0x04, 0xb6, 0x17, 0xd8, 0x87, 0x11, 0x94, 0x0f, 0x23,
+ 0xb8, 0x2e, 0x15, 0x78, 0xdb, 0x58, 0x96, 0x7d, 0xfb, 0x4f, 0x0d, 0xbc, 0xca, 0x7d, 0x20, 0x0c,
+ 0x8d, 0x59, 0xc2, 0xd2, 0x3c, 0x49, 0xed, 0x27, 0x6c, 0x3f, 0x27, 0xae, 0x0a, 0x20, 0xb8, 0x2c,
+ 0xdc, 0x78, 0xc9, 0x41, 0xef, 0xc0, 0x27, 0xdf, 0xe7, 0x5c, 0x28, 0x22, 0xe2, 0x05, 0x11, 0x92,
+ 0x72, 0x56, 0x44, 0xb2, 0x53, 0xce, 0x6f, 0xed, 0x18, 0xbd, 0x87, 0xdd, 0x09, 0x17, 0x24, 0x2e,
+ 0x1f, 0x56, 0x29, 0x77, 0x8d, 0x1c, 0xe9, 0x5d, 0x71, 0x58, 0xe1, 0x68, 0xff, 0x72, 0xa0, 0x51,
+ 0x9e, 0x89, 0x5a, 0xb0, 0x7b, 0xd9, 0x1d, 0x9e, 0xdd, 0x74, 0xcf, 0xfa, 0xf1, 0xcd, 0x70, 0x14,
+ 0xf5, 0x7b, 0x83, 0x2f, 0x83, 0xfe, 0xa9, 0xff, 0x1f, 0xda, 0x02, 0xb7, 0x17, 0x45, 0xbe, 0x83,
+ 0x3c, 0xd8, 0xea, 0xc5, 0xa3, 0xf3, 0x2e, 0x8e, 0xfc, 0x1a, 0x02, 0xd8, 0xec, 0x63, 0xed, 0xf0,
+ 0x5d, 0xbd, 0x38, 0xbb, 0x8a, 0x4d, 0x53, 0x47, 0x0d, 0xa8, 0x5f, 0x74, 0x6f, 0xbb, 0xfe, 0x86,
+ 0x1e, 0x0f, 0xaf, 0x4e, 0xfb, 0xf1, 0xc5, 0xc8, 0xdf, 0xd4, 0x94, 0xe8, 0x3c, 0xf2, 0xb7, 0xb4,
+ 0x31, 0xba, 0xbb, 0x3e, 0xbf, 0x1a, 0xfa, 0x0d, 0xad, 0xc5, 0x37, 0x27, 0x77, 0x7e, 0xb3, 0xfd,
+ 0x06, 0xbc, 0xca, 0x4b, 0x44, 0x08, 0xea, 0x95, 0xab, 0x34, 0xf5, 0xc9, 0x0f, 0x78, 0x4b, 0xf9,
+ 0xda, 0x44, 0x4f, 0xbc, 0x9e, 0x29, 0x23, 0xbd, 0x8c, 0x9c, 0xaf, 0x83, 0x94, 0xaa, 0x87, 0x7c,
+ 0xac, 0x05, 0xa1, 0xf5, 0x75, 0x28, 0x93, 0x4a, 0xe4, 0x19, 0x61, 0x2a, 0x51, 0x94, 0xb3, 0x70,
+ 0x85, 0xec, 0xd8, 0x9f, 0x4b, 0x4a, 0x58, 0x27, 0x7d, 0xf2, 0x8f, 0x19, 0x6f, 0x9a, 0xed, 0xf1,
+ 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x94, 0xe5, 0x77, 0x76, 0x8e, 0x04, 0x00, 0x00,
+}
diff --git a/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/agent/trace/v1/trace_service.pb.go b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/agent/trace/v1/trace_service.pb.go
new file mode 100644
index 0000000000..01eddf4cc1
--- /dev/null
+++ b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/agent/trace/v1/trace_service.pb.go
@@ -0,0 +1,443 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: opencensus/proto/agent/trace/v1/trace_service.proto
+
+package v1
+
+import (
+ fmt "fmt"
+ v1 "github.com/census-instrumentation/opencensus-proto/gen-go/agent/common/v1"
+ v12 "github.com/census-instrumentation/opencensus-proto/gen-go/resource/v1"
+ v11 "github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1"
+ proto "github.com/golang/protobuf/proto"
+ context "golang.org/x/net/context"
+ grpc "google.golang.org/grpc"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type CurrentLibraryConfig struct {
+ // This is required only in the first message on the stream or if the
+ // previous sent CurrentLibraryConfig message has a different Node (e.g.
+ // when the same RPC is used to configure multiple Applications).
+ Node *v1.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+ // Current configuration.
+ Config *v11.TraceConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *CurrentLibraryConfig) Reset() { *m = CurrentLibraryConfig{} }
+func (m *CurrentLibraryConfig) String() string { return proto.CompactTextString(m) }
+func (*CurrentLibraryConfig) ProtoMessage() {}
+func (*CurrentLibraryConfig) Descriptor() ([]byte, []int) {
+ return fileDescriptor_7027f99caf7ac6a5, []int{0}
+}
+
+func (m *CurrentLibraryConfig) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_CurrentLibraryConfig.Unmarshal(m, b)
+}
+func (m *CurrentLibraryConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_CurrentLibraryConfig.Marshal(b, m, deterministic)
+}
+func (m *CurrentLibraryConfig) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CurrentLibraryConfig.Merge(m, src)
+}
+func (m *CurrentLibraryConfig) XXX_Size() int {
+ return xxx_messageInfo_CurrentLibraryConfig.Size(m)
+}
+func (m *CurrentLibraryConfig) XXX_DiscardUnknown() {
+ xxx_messageInfo_CurrentLibraryConfig.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CurrentLibraryConfig proto.InternalMessageInfo
+
+func (m *CurrentLibraryConfig) GetNode() *v1.Node {
+ if m != nil {
+ return m.Node
+ }
+ return nil
+}
+
+func (m *CurrentLibraryConfig) GetConfig() *v11.TraceConfig {
+ if m != nil {
+ return m.Config
+ }
+ return nil
+}
+
+type UpdatedLibraryConfig struct {
+ // This field is ignored when the RPC is used to configure only one Application.
+ // This is required only in the first message on the stream or if the
+ // previous sent UpdatedLibraryConfig message has a different Node.
+ Node *v1.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+ // Requested updated configuration.
+ Config *v11.TraceConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *UpdatedLibraryConfig) Reset() { *m = UpdatedLibraryConfig{} }
+func (m *UpdatedLibraryConfig) String() string { return proto.CompactTextString(m) }
+func (*UpdatedLibraryConfig) ProtoMessage() {}
+func (*UpdatedLibraryConfig) Descriptor() ([]byte, []int) {
+ return fileDescriptor_7027f99caf7ac6a5, []int{1}
+}
+
+func (m *UpdatedLibraryConfig) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_UpdatedLibraryConfig.Unmarshal(m, b)
+}
+func (m *UpdatedLibraryConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_UpdatedLibraryConfig.Marshal(b, m, deterministic)
+}
+func (m *UpdatedLibraryConfig) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_UpdatedLibraryConfig.Merge(m, src)
+}
+func (m *UpdatedLibraryConfig) XXX_Size() int {
+ return xxx_messageInfo_UpdatedLibraryConfig.Size(m)
+}
+func (m *UpdatedLibraryConfig) XXX_DiscardUnknown() {
+ xxx_messageInfo_UpdatedLibraryConfig.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdatedLibraryConfig proto.InternalMessageInfo
+
+func (m *UpdatedLibraryConfig) GetNode() *v1.Node {
+ if m != nil {
+ return m.Node
+ }
+ return nil
+}
+
+func (m *UpdatedLibraryConfig) GetConfig() *v11.TraceConfig {
+ if m != nil {
+ return m.Config
+ }
+ return nil
+}
+
+type ExportTraceServiceRequest struct {
+ // This is required only in the first message on the stream or if the
+ // previous sent ExportTraceServiceRequest message has a different Node (e.g.
+ // when the same RPC is used to send Spans from multiple Applications).
+ Node *v1.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+ // A list of Spans that belong to the last received Node.
+ Spans []*v11.Span `protobuf:"bytes,2,rep,name=spans,proto3" json:"spans,omitempty"`
+ // The resource for the spans in this message that do not have an explicit
+ // resource set.
+ // If unset, the most recently set resource in the RPC stream applies. It is
+ // valid to never be set within a stream, e.g. when no resource info is known.
+ Resource *v12.Resource `protobuf:"bytes,3,opt,name=resource,proto3" json:"resource,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ExportTraceServiceRequest) Reset() { *m = ExportTraceServiceRequest{} }
+func (m *ExportTraceServiceRequest) String() string { return proto.CompactTextString(m) }
+func (*ExportTraceServiceRequest) ProtoMessage() {}
+func (*ExportTraceServiceRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_7027f99caf7ac6a5, []int{2}
+}
+
+func (m *ExportTraceServiceRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ExportTraceServiceRequest.Unmarshal(m, b)
+}
+func (m *ExportTraceServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ExportTraceServiceRequest.Marshal(b, m, deterministic)
+}
+func (m *ExportTraceServiceRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExportTraceServiceRequest.Merge(m, src)
+}
+func (m *ExportTraceServiceRequest) XXX_Size() int {
+ return xxx_messageInfo_ExportTraceServiceRequest.Size(m)
+}
+func (m *ExportTraceServiceRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExportTraceServiceRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExportTraceServiceRequest proto.InternalMessageInfo
+
+func (m *ExportTraceServiceRequest) GetNode() *v1.Node {
+ if m != nil {
+ return m.Node
+ }
+ return nil
+}
+
+func (m *ExportTraceServiceRequest) GetSpans() []*v11.Span {
+ if m != nil {
+ return m.Spans
+ }
+ return nil
+}
+
+func (m *ExportTraceServiceRequest) GetResource() *v12.Resource {
+ if m != nil {
+ return m.Resource
+ }
+ return nil
+}
+
+type ExportTraceServiceResponse struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ExportTraceServiceResponse) Reset() { *m = ExportTraceServiceResponse{} }
+func (m *ExportTraceServiceResponse) String() string { return proto.CompactTextString(m) }
+func (*ExportTraceServiceResponse) ProtoMessage() {}
+func (*ExportTraceServiceResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_7027f99caf7ac6a5, []int{3}
+}
+
+func (m *ExportTraceServiceResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ExportTraceServiceResponse.Unmarshal(m, b)
+}
+func (m *ExportTraceServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ExportTraceServiceResponse.Marshal(b, m, deterministic)
+}
+func (m *ExportTraceServiceResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExportTraceServiceResponse.Merge(m, src)
+}
+func (m *ExportTraceServiceResponse) XXX_Size() int {
+ return xxx_messageInfo_ExportTraceServiceResponse.Size(m)
+}
+func (m *ExportTraceServiceResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExportTraceServiceResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExportTraceServiceResponse proto.InternalMessageInfo
+
+func init() {
+ proto.RegisterType((*CurrentLibraryConfig)(nil), "opencensus.proto.agent.trace.v1.CurrentLibraryConfig")
+ proto.RegisterType((*UpdatedLibraryConfig)(nil), "opencensus.proto.agent.trace.v1.UpdatedLibraryConfig")
+ proto.RegisterType((*ExportTraceServiceRequest)(nil), "opencensus.proto.agent.trace.v1.ExportTraceServiceRequest")
+ proto.RegisterType((*ExportTraceServiceResponse)(nil), "opencensus.proto.agent.trace.v1.ExportTraceServiceResponse")
+}
+
+func init() {
+ proto.RegisterFile("opencensus/proto/agent/trace/v1/trace_service.proto", fileDescriptor_7027f99caf7ac6a5)
+}
+
+var fileDescriptor_7027f99caf7ac6a5 = []byte{
+ // 423 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x54, 0xbf, 0x6b, 0xdb, 0x40,
+ 0x14, 0xee, 0xd9, 0xad, 0x28, 0xe7, 0x2e, 0x15, 0x1d, 0x54, 0x51, 0xb0, 0x11, 0xb4, 0x18, 0x5a,
+ 0x9d, 0x2a, 0x1b, 0x2f, 0x2e, 0x74, 0xb0, 0x29, 0x74, 0x28, 0xc5, 0xc8, 0xed, 0x92, 0xc5, 0xc8,
+ 0xd2, 0x8b, 0xa2, 0xc1, 0x77, 0xca, 0xdd, 0x49, 0x24, 0x90, 0x2d, 0x43, 0xf6, 0x0c, 0xf9, 0xc3,
+ 0xf2, 0x17, 0x05, 0xdd, 0xc9, 0x3f, 0x12, 0x5b, 0x11, 0x24, 0x4b, 0xb6, 0x87, 0xde, 0xf7, 0x7d,
+ 0xf7, 0xbd, 0x7b, 0xdf, 0x09, 0x0f, 0x59, 0x06, 0x34, 0x02, 0x2a, 0x72, 0xe1, 0x65, 0x9c, 0x49,
+ 0xe6, 0x85, 0x09, 0x50, 0xe9, 0x49, 0x1e, 0x46, 0xe0, 0x15, 0xbe, 0x2e, 0x16, 0x02, 0x78, 0x91,
+ 0x46, 0x40, 0x14, 0xc4, 0xec, 0x6e, 0x49, 0xfa, 0x0b, 0x51, 0x24, 0xa2, 0xb0, 0xa4, 0xf0, 0x6d,
+ 0xb7, 0x46, 0x35, 0x62, 0xab, 0x15, 0xa3, 0xa5, 0xac, 0xae, 0x34, 0xdb, 0xfe, 0xba, 0x07, 0xe7,
+ 0x20, 0x58, 0xce, 0xb5, 0x83, 0x75, 0x5d, 0x81, 0x3f, 0xef, 0x81, 0xef, 0x7b, 0xad, 0x60, 0xdf,
+ 0x1a, 0x60, 0x8b, 0x88, 0xd1, 0xe3, 0x34, 0xd1, 0x68, 0xe7, 0x1a, 0xe1, 0x0f, 0xd3, 0x9c, 0x73,
+ 0xa0, 0xf2, 0x4f, 0xba, 0xe4, 0x21, 0x3f, 0x9f, 0xaa, 0xb6, 0x39, 0xc6, 0xaf, 0x29, 0x8b, 0xc1,
+ 0x42, 0x3d, 0xd4, 0xef, 0x0c, 0xbe, 0x90, 0x9a, 0xc9, 0xab, 0x71, 0x0a, 0x9f, 0xfc, 0x65, 0x31,
+ 0x04, 0x8a, 0x63, 0xfe, 0xc4, 0x86, 0x3e, 0xc4, 0x6a, 0xd5, 0xb1, 0xd7, 0x37, 0x46, 0xfe, 0x95,
+ 0x85, 0x3e, 0x33, 0xa8, 0x58, 0xca, 0xd4, 0xff, 0x2c, 0x0e, 0x25, 0xc4, 0x2f, 0xc7, 0xd4, 0x2d,
+ 0xc2, 0x1f, 0x7f, 0x9d, 0x65, 0x8c, 0x4b, 0xd5, 0x9d, 0xeb, 0x60, 0x04, 0x70, 0x9a, 0x83, 0x90,
+ 0xcf, 0x72, 0x36, 0xc2, 0x6f, 0x44, 0x16, 0x52, 0x61, 0xb5, 0x7a, 0xed, 0x7e, 0x67, 0xd0, 0x7d,
+ 0xc4, 0xd8, 0x3c, 0x0b, 0x69, 0xa0, 0xd1, 0xe6, 0x04, 0xbf, 0x5d, 0x27, 0xc4, 0x6a, 0xd7, 0x1d,
+ 0xbb, 0xc9, 0x50, 0xe1, 0x93, 0xa0, 0xaa, 0x83, 0x0d, 0xcf, 0xf9, 0x84, 0xed, 0x43, 0x33, 0x89,
+ 0x8c, 0x51, 0x01, 0x83, 0x9b, 0x16, 0x7e, 0xb7, 0xdb, 0x30, 0x2f, 0xb0, 0x51, 0x6d, 0x62, 0x44,
+ 0x1a, 0x9e, 0x02, 0x39, 0x94, 0x2a, 0xbb, 0x99, 0x76, 0x68, 0xef, 0xce, 0xab, 0x3e, 0xfa, 0x8e,
+ 0xcc, 0x2b, 0x84, 0x0d, 0xed, 0xd6, 0x1c, 0x37, 0xea, 0xd4, 0xae, 0xca, 0xfe, 0xf1, 0x24, 0xae,
+ 0xbe, 0x12, 0xed, 0x64, 0x72, 0x89, 0xb0, 0x93, 0xb2, 0x26, 0x9d, 0xc9, 0xfb, 0x5d, 0x89, 0x59,
+ 0x89, 0x98, 0xa1, 0xa3, 0xdf, 0x49, 0x2a, 0x4f, 0xf2, 0x65, 0x19, 0x05, 0x4f, 0x93, 0xdd, 0x94,
+ 0x0a, 0xc9, 0xf3, 0x15, 0x50, 0x19, 0xca, 0x94, 0x51, 0x6f, 0xab, 0xeb, 0xea, 0x17, 0x9c, 0x00,
+ 0x75, 0x93, 0x87, 0x7f, 0xa8, 0xa5, 0xa1, 0x9a, 0xc3, 0xbb, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcf,
+ 0x9c, 0x9b, 0xf7, 0xcb, 0x04, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// TraceServiceClient is the client API for TraceService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type TraceServiceClient interface {
+ // After initialization, this RPC must be kept alive for the entire life of
+ // the application. The agent pushes configs down to applications via a
+ // stream.
+ Config(ctx context.Context, opts ...grpc.CallOption) (TraceService_ConfigClient, error)
+ // For performance reasons, it is recommended to keep this RPC
+ // alive for the entire life of the application.
+ Export(ctx context.Context, opts ...grpc.CallOption) (TraceService_ExportClient, error)
+}
+
+type traceServiceClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewTraceServiceClient(cc *grpc.ClientConn) TraceServiceClient {
+ return &traceServiceClient{cc}
+}
+
+func (c *traceServiceClient) Config(ctx context.Context, opts ...grpc.CallOption) (TraceService_ConfigClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_TraceService_serviceDesc.Streams[0], "/opencensus.proto.agent.trace.v1.TraceService/Config", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &traceServiceConfigClient{stream}
+ return x, nil
+}
+
+type TraceService_ConfigClient interface {
+ Send(*CurrentLibraryConfig) error
+ Recv() (*UpdatedLibraryConfig, error)
+ grpc.ClientStream
+}
+
+type traceServiceConfigClient struct {
+ grpc.ClientStream
+}
+
+func (x *traceServiceConfigClient) Send(m *CurrentLibraryConfig) error {
+ return x.ClientStream.SendMsg(m)
+}
+
+func (x *traceServiceConfigClient) Recv() (*UpdatedLibraryConfig, error) {
+ m := new(UpdatedLibraryConfig)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func (c *traceServiceClient) Export(ctx context.Context, opts ...grpc.CallOption) (TraceService_ExportClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_TraceService_serviceDesc.Streams[1], "/opencensus.proto.agent.trace.v1.TraceService/Export", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &traceServiceExportClient{stream}
+ return x, nil
+}
+
+type TraceService_ExportClient interface {
+ Send(*ExportTraceServiceRequest) error
+ Recv() (*ExportTraceServiceResponse, error)
+ grpc.ClientStream
+}
+
+type traceServiceExportClient struct {
+ grpc.ClientStream
+}
+
+func (x *traceServiceExportClient) Send(m *ExportTraceServiceRequest) error {
+ return x.ClientStream.SendMsg(m)
+}
+
+func (x *traceServiceExportClient) Recv() (*ExportTraceServiceResponse, error) {
+ m := new(ExportTraceServiceResponse)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+// TraceServiceServer is the server API for TraceService service.
+type TraceServiceServer interface {
+ // After initialization, this RPC must be kept alive for the entire life of
+ // the application. The agent pushes configs down to applications via a
+ // stream.
+ Config(TraceService_ConfigServer) error
+ // For performance reasons, it is recommended to keep this RPC
+ // alive for the entire life of the application.
+ Export(TraceService_ExportServer) error
+}
+
+func RegisterTraceServiceServer(s *grpc.Server, srv TraceServiceServer) {
+ s.RegisterService(&_TraceService_serviceDesc, srv)
+}
+
+func _TraceService_Config_Handler(srv interface{}, stream grpc.ServerStream) error {
+ return srv.(TraceServiceServer).Config(&traceServiceConfigServer{stream})
+}
+
+type TraceService_ConfigServer interface {
+ Send(*UpdatedLibraryConfig) error
+ Recv() (*CurrentLibraryConfig, error)
+ grpc.ServerStream
+}
+
+type traceServiceConfigServer struct {
+ grpc.ServerStream
+}
+
+func (x *traceServiceConfigServer) Send(m *UpdatedLibraryConfig) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func (x *traceServiceConfigServer) Recv() (*CurrentLibraryConfig, error) {
+ m := new(CurrentLibraryConfig)
+ if err := x.ServerStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func _TraceService_Export_Handler(srv interface{}, stream grpc.ServerStream) error {
+ return srv.(TraceServiceServer).Export(&traceServiceExportServer{stream})
+}
+
+type TraceService_ExportServer interface {
+ Send(*ExportTraceServiceResponse) error
+ Recv() (*ExportTraceServiceRequest, error)
+ grpc.ServerStream
+}
+
+type traceServiceExportServer struct {
+ grpc.ServerStream
+}
+
+func (x *traceServiceExportServer) Send(m *ExportTraceServiceResponse) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func (x *traceServiceExportServer) Recv() (*ExportTraceServiceRequest, error) {
+ m := new(ExportTraceServiceRequest)
+ if err := x.ServerStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+var _TraceService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "opencensus.proto.agent.trace.v1.TraceService",
+ HandlerType: (*TraceServiceServer)(nil),
+ Methods: []grpc.MethodDesc{},
+ Streams: []grpc.StreamDesc{
+ {
+ StreamName: "Config",
+ Handler: _TraceService_Config_Handler,
+ ServerStreams: true,
+ ClientStreams: true,
+ },
+ {
+ StreamName: "Export",
+ Handler: _TraceService_Export_Handler,
+ ServerStreams: true,
+ ClientStreams: true,
+ },
+ },
+ Metadata: "opencensus/proto/agent/trace/v1/trace_service.proto",
+}
diff --git a/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/resource/v1/resource.pb.go b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/resource/v1/resource.pb.go
new file mode 100644
index 0000000000..560dbd94a0
--- /dev/null
+++ b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/resource/v1/resource.pb.go
@@ -0,0 +1,99 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: opencensus/proto/resource/v1/resource.proto
+
+package v1
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Resource information.
+type Resource struct {
+ // Type identifier for the resource.
+ Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
+ // Set of labels that describe the resource.
+ Labels map[string]string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Resource) Reset() { *m = Resource{} }
+func (m *Resource) String() string { return proto.CompactTextString(m) }
+func (*Resource) ProtoMessage() {}
+func (*Resource) Descriptor() ([]byte, []int) {
+ return fileDescriptor_584700775a2fc762, []int{0}
+}
+
+func (m *Resource) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Resource.Unmarshal(m, b)
+}
+func (m *Resource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Resource.Marshal(b, m, deterministic)
+}
+func (m *Resource) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Resource.Merge(m, src)
+}
+func (m *Resource) XXX_Size() int {
+ return xxx_messageInfo_Resource.Size(m)
+}
+func (m *Resource) XXX_DiscardUnknown() {
+ xxx_messageInfo_Resource.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Resource proto.InternalMessageInfo
+
+func (m *Resource) GetType() string {
+ if m != nil {
+ return m.Type
+ }
+ return ""
+}
+
+func (m *Resource) GetLabels() map[string]string {
+ if m != nil {
+ return m.Labels
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*Resource)(nil), "opencensus.proto.resource.v1.Resource")
+ proto.RegisterMapType((map[string]string)(nil), "opencensus.proto.resource.v1.Resource.LabelsEntry")
+}
+
+func init() {
+ proto.RegisterFile("opencensus/proto/resource/v1/resource.proto", fileDescriptor_584700775a2fc762)
+}
+
+var fileDescriptor_584700775a2fc762 = []byte{
+ // 234 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xce, 0x2f, 0x48, 0xcd,
+ 0x4b, 0x4e, 0xcd, 0x2b, 0x2e, 0x2d, 0xd6, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0xd7, 0x2f, 0x4a, 0x2d,
+ 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5, 0x2f, 0x33, 0x84, 0xb3, 0xf5, 0xc0, 0x52, 0x42, 0x32, 0x08,
+ 0xc5, 0x10, 0x11, 0x3d, 0xb8, 0x82, 0x32, 0x43, 0xa5, 0xa5, 0x8c, 0x5c, 0x1c, 0x41, 0x50, 0xbe,
+ 0x90, 0x10, 0x17, 0x4b, 0x49, 0x65, 0x41, 0xaa, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x98,
+ 0x2d, 0xe4, 0xc5, 0xc5, 0x96, 0x93, 0x98, 0x94, 0x9a, 0x53, 0x2c, 0xc1, 0xa4, 0xc0, 0xac, 0xc1,
+ 0x6d, 0x64, 0xa4, 0x87, 0xcf, 0x3c, 0x3d, 0x98, 0x59, 0x7a, 0x3e, 0x60, 0x4d, 0xae, 0x79, 0x25,
+ 0x45, 0x95, 0x41, 0x50, 0x13, 0xa4, 0x2c, 0xb9, 0xb8, 0x91, 0x84, 0x85, 0x04, 0xb8, 0x98, 0xb3,
+ 0x53, 0x2b, 0xa1, 0xb6, 0x81, 0x98, 0x42, 0x22, 0x5c, 0xac, 0x65, 0x89, 0x39, 0xa5, 0xa9, 0x12,
+ 0x4c, 0x60, 0x31, 0x08, 0xc7, 0x8a, 0xc9, 0x82, 0xd1, 0xa9, 0x92, 0x4b, 0x3e, 0x33, 0x1f, 0xaf,
+ 0xd5, 0x4e, 0xbc, 0x30, 0xbb, 0x03, 0x40, 0x52, 0x01, 0x8c, 0x51, 0xae, 0xe9, 0x99, 0x25, 0x19,
+ 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x10, 0x5d, 0xba, 0x99, 0x79, 0xc5, 0x25, 0x45, 0xa5,
+ 0xb9, 0xa9, 0x79, 0x25, 0x89, 0x25, 0x99, 0xf9, 0x79, 0xfa, 0x08, 0x03, 0x75, 0x21, 0x01, 0x99,
+ 0x9e, 0x9a, 0xa7, 0x9b, 0x8e, 0x12, 0x9e, 0x49, 0x6c, 0x60, 0x19, 0x63, 0x40, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x8e, 0x11, 0xaf, 0xda, 0x76, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1/trace.pb.go b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1/trace.pb.go
new file mode 100644
index 0000000000..c34e388922
--- /dev/null
+++ b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1/trace.pb.go
@@ -0,0 +1,1654 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: opencensus/proto/trace/v1/trace.proto
+
+package v1
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ timestamp "github.com/golang/protobuf/ptypes/timestamp"
+ wrappers "github.com/golang/protobuf/ptypes/wrappers"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Type of span. Can be used to specify additional relationships between spans
+// in addition to a parent/child relationship.
+type Span_SpanKind int32
+
+const (
+ // Unspecified.
+ Span_SPAN_KIND_UNSPECIFIED Span_SpanKind = 0
+ // Indicates that the span covers server-side handling of an RPC or other
+ // remote network request.
+ Span_SERVER Span_SpanKind = 1
+ // Indicates that the span covers the client-side wrapper around an RPC or
+ // other remote request.
+ Span_CLIENT Span_SpanKind = 2
+)
+
+var Span_SpanKind_name = map[int32]string{
+ 0: "SPAN_KIND_UNSPECIFIED",
+ 1: "SERVER",
+ 2: "CLIENT",
+}
+
+var Span_SpanKind_value = map[string]int32{
+ "SPAN_KIND_UNSPECIFIED": 0,
+ "SERVER": 1,
+ "CLIENT": 2,
+}
+
+func (x Span_SpanKind) String() string {
+ return proto.EnumName(Span_SpanKind_name, int32(x))
+}
+
+func (Span_SpanKind) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 0}
+}
+
+// Indicates whether the message was sent or received.
+type Span_TimeEvent_MessageEvent_Type int32
+
+const (
+ // Unknown event type.
+ Span_TimeEvent_MessageEvent_TYPE_UNSPECIFIED Span_TimeEvent_MessageEvent_Type = 0
+ // Indicates a sent message.
+ Span_TimeEvent_MessageEvent_SENT Span_TimeEvent_MessageEvent_Type = 1
+ // Indicates a received message.
+ Span_TimeEvent_MessageEvent_RECEIVED Span_TimeEvent_MessageEvent_Type = 2
+)
+
+var Span_TimeEvent_MessageEvent_Type_name = map[int32]string{
+ 0: "TYPE_UNSPECIFIED",
+ 1: "SENT",
+ 2: "RECEIVED",
+}
+
+var Span_TimeEvent_MessageEvent_Type_value = map[string]int32{
+ "TYPE_UNSPECIFIED": 0,
+ "SENT": 1,
+ "RECEIVED": 2,
+}
+
+func (x Span_TimeEvent_MessageEvent_Type) String() string {
+ return proto.EnumName(Span_TimeEvent_MessageEvent_Type_name, int32(x))
+}
+
+func (Span_TimeEvent_MessageEvent_Type) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 2, 1, 0}
+}
+
+// The relationship of the current span relative to the linked span: child,
+// parent, or unspecified.
+type Span_Link_Type int32
+
+const (
+ // The relationship of the two spans is unknown, or known but other
+ // than parent-child.
+ Span_Link_TYPE_UNSPECIFIED Span_Link_Type = 0
+ // The linked span is a child of the current span.
+ Span_Link_CHILD_LINKED_SPAN Span_Link_Type = 1
+ // The linked span is a parent of the current span.
+ Span_Link_PARENT_LINKED_SPAN Span_Link_Type = 2
+)
+
+var Span_Link_Type_name = map[int32]string{
+ 0: "TYPE_UNSPECIFIED",
+ 1: "CHILD_LINKED_SPAN",
+ 2: "PARENT_LINKED_SPAN",
+}
+
+var Span_Link_Type_value = map[string]int32{
+ "TYPE_UNSPECIFIED": 0,
+ "CHILD_LINKED_SPAN": 1,
+ "PARENT_LINKED_SPAN": 2,
+}
+
+func (x Span_Link_Type) String() string {
+ return proto.EnumName(Span_Link_Type_name, int32(x))
+}
+
+func (Span_Link_Type) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 4, 0}
+}
+
+// A span represents a single operation within a trace. Spans can be
+// nested to form a trace tree. Often, a trace contains a root span
+// that describes the end-to-end latency, and one or more subspans for
+// its sub-operations. A trace can also contain multiple root spans,
+// or none at all. Spans do not need to be contiguous - there may be
+// gaps or overlaps between spans in a trace.
+//
+// The next id is 16.
+// TODO(bdrutu): Add an example.
+type Span struct {
+ // A unique identifier for a trace. All spans from the same trace share
+ // the same `trace_id`. The ID is a 16-byte array.
+ //
+ // This field is required.
+ TraceId []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
+ // A unique identifier for a span within a trace, assigned when the span
+ // is created. The ID is an 8-byte array.
+ //
+ // This field is required.
+ SpanId []byte `protobuf:"bytes,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"`
+ // The Tracestate on the span.
+ Tracestate *Span_Tracestate `protobuf:"bytes,15,opt,name=tracestate,proto3" json:"tracestate,omitempty"`
+ // The `span_id` of this span's parent span. If this is a root span, then this
+ // field must be empty. The ID is an 8-byte array.
+ ParentSpanId []byte `protobuf:"bytes,3,opt,name=parent_span_id,json=parentSpanId,proto3" json:"parent_span_id,omitempty"`
+ // A description of the span's operation.
+ //
+ // For example, the name can be a qualified method name or a file name
+ // and a line number where the operation is called. A best practice is to use
+ // the same display name at the same call point in an application.
+ // This makes it easier to correlate spans in different traces.
+ //
+ // This field is required.
+ Name *TruncatableString `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
+ // Distinguishes between spans generated in a particular context. For example,
+ // two spans with the same name may be distinguished using `CLIENT`
+ // and `SERVER` to identify queueing latency associated with the span.
+ Kind Span_SpanKind `protobuf:"varint,14,opt,name=kind,proto3,enum=opencensus.proto.trace.v1.Span_SpanKind" json:"kind,omitempty"`
+ // The start time of the span. On the client side, this is the time kept by
+ // the local machine where the span execution starts. On the server side, this
+ // is the time when the server's application handler starts running.
+ StartTime *timestamp.Timestamp `protobuf:"bytes,5,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
+ // The end time of the span. On the client side, this is the time kept by
+ // the local machine where the span execution ends. On the server side, this
+ // is the time when the server application handler stops running.
+ EndTime *timestamp.Timestamp `protobuf:"bytes,6,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
+ // A set of attributes on the span.
+ Attributes *Span_Attributes `protobuf:"bytes,7,opt,name=attributes,proto3" json:"attributes,omitempty"`
+ // A stack trace captured at the start of the span.
+ StackTrace *StackTrace `protobuf:"bytes,8,opt,name=stack_trace,json=stackTrace,proto3" json:"stack_trace,omitempty"`
+ // The included time events.
+ TimeEvents *Span_TimeEvents `protobuf:"bytes,9,opt,name=time_events,json=timeEvents,proto3" json:"time_events,omitempty"`
+ // The included links.
+ Links *Span_Links `protobuf:"bytes,10,opt,name=links,proto3" json:"links,omitempty"`
+ // An optional final status for this span.
+ Status *Status `protobuf:"bytes,11,opt,name=status,proto3" json:"status,omitempty"`
+ // A highly recommended but not required flag that identifies when a trace
+ // crosses a process boundary. True when the parent_span belongs to the
+ // same process as the current span.
+ SameProcessAsParentSpan *wrappers.BoolValue `protobuf:"bytes,12,opt,name=same_process_as_parent_span,json=sameProcessAsParentSpan,proto3" json:"same_process_as_parent_span,omitempty"`
+ // An optional number of child spans that were generated while this span
+ // was active. If set, allows an implementation to detect missing child spans.
+ ChildSpanCount *wrappers.UInt32Value `protobuf:"bytes,13,opt,name=child_span_count,json=childSpanCount,proto3" json:"child_span_count,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span) Reset() { *m = Span{} }
+func (m *Span) String() string { return proto.CompactTextString(m) }
+func (*Span) ProtoMessage() {}
+func (*Span) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0}
+}
+
+func (m *Span) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span.Unmarshal(m, b)
+}
+func (m *Span) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span.Marshal(b, m, deterministic)
+}
+func (m *Span) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span.Merge(m, src)
+}
+func (m *Span) XXX_Size() int {
+ return xxx_messageInfo_Span.Size(m)
+}
+func (m *Span) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span proto.InternalMessageInfo
+
+func (m *Span) GetTraceId() []byte {
+ if m != nil {
+ return m.TraceId
+ }
+ return nil
+}
+
+func (m *Span) GetSpanId() []byte {
+ if m != nil {
+ return m.SpanId
+ }
+ return nil
+}
+
+func (m *Span) GetTracestate() *Span_Tracestate {
+ if m != nil {
+ return m.Tracestate
+ }
+ return nil
+}
+
+func (m *Span) GetParentSpanId() []byte {
+ if m != nil {
+ return m.ParentSpanId
+ }
+ return nil
+}
+
+func (m *Span) GetName() *TruncatableString {
+ if m != nil {
+ return m.Name
+ }
+ return nil
+}
+
+func (m *Span) GetKind() Span_SpanKind {
+ if m != nil {
+ return m.Kind
+ }
+ return Span_SPAN_KIND_UNSPECIFIED
+}
+
+func (m *Span) GetStartTime() *timestamp.Timestamp {
+ if m != nil {
+ return m.StartTime
+ }
+ return nil
+}
+
+func (m *Span) GetEndTime() *timestamp.Timestamp {
+ if m != nil {
+ return m.EndTime
+ }
+ return nil
+}
+
+func (m *Span) GetAttributes() *Span_Attributes {
+ if m != nil {
+ return m.Attributes
+ }
+ return nil
+}
+
+func (m *Span) GetStackTrace() *StackTrace {
+ if m != nil {
+ return m.StackTrace
+ }
+ return nil
+}
+
+func (m *Span) GetTimeEvents() *Span_TimeEvents {
+ if m != nil {
+ return m.TimeEvents
+ }
+ return nil
+}
+
+func (m *Span) GetLinks() *Span_Links {
+ if m != nil {
+ return m.Links
+ }
+ return nil
+}
+
+func (m *Span) GetStatus() *Status {
+ if m != nil {
+ return m.Status
+ }
+ return nil
+}
+
+func (m *Span) GetSameProcessAsParentSpan() *wrappers.BoolValue {
+ if m != nil {
+ return m.SameProcessAsParentSpan
+ }
+ return nil
+}
+
+func (m *Span) GetChildSpanCount() *wrappers.UInt32Value {
+ if m != nil {
+ return m.ChildSpanCount
+ }
+ return nil
+}
+
+// This field conveys information about request position in multiple distributed tracing graphs.
+// It is a list of Tracestate.Entry with a maximum of 32 members in the list.
+//
+// See the https://github.com/w3c/distributed-tracing for more details about this field.
+type Span_Tracestate struct {
+ // A list of entries that represent the Tracestate.
+ Entries []*Span_Tracestate_Entry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span_Tracestate) Reset() { *m = Span_Tracestate{} }
+func (m *Span_Tracestate) String() string { return proto.CompactTextString(m) }
+func (*Span_Tracestate) ProtoMessage() {}
+func (*Span_Tracestate) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 0}
+}
+
+func (m *Span_Tracestate) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span_Tracestate.Unmarshal(m, b)
+}
+func (m *Span_Tracestate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span_Tracestate.Marshal(b, m, deterministic)
+}
+func (m *Span_Tracestate) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span_Tracestate.Merge(m, src)
+}
+func (m *Span_Tracestate) XXX_Size() int {
+ return xxx_messageInfo_Span_Tracestate.Size(m)
+}
+func (m *Span_Tracestate) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span_Tracestate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span_Tracestate proto.InternalMessageInfo
+
+func (m *Span_Tracestate) GetEntries() []*Span_Tracestate_Entry {
+ if m != nil {
+ return m.Entries
+ }
+ return nil
+}
+
+type Span_Tracestate_Entry struct {
+ // The key must begin with a lowercase letter, and can only contain
+ // lowercase letters 'a'-'z', digits '0'-'9', underscores '_', dashes
+ // '-', asterisks '*', and forward slashes '/'.
+ Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+ // The value is opaque string up to 256 characters printable ASCII
+ // RFC0020 characters (i.e., the range 0x20 to 0x7E) except ',' and '='.
+ // Note that this also excludes tabs, newlines, carriage returns, etc.
+ Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span_Tracestate_Entry) Reset() { *m = Span_Tracestate_Entry{} }
+func (m *Span_Tracestate_Entry) String() string { return proto.CompactTextString(m) }
+func (*Span_Tracestate_Entry) ProtoMessage() {}
+func (*Span_Tracestate_Entry) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 0, 0}
+}
+
+func (m *Span_Tracestate_Entry) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span_Tracestate_Entry.Unmarshal(m, b)
+}
+func (m *Span_Tracestate_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span_Tracestate_Entry.Marshal(b, m, deterministic)
+}
+func (m *Span_Tracestate_Entry) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span_Tracestate_Entry.Merge(m, src)
+}
+func (m *Span_Tracestate_Entry) XXX_Size() int {
+ return xxx_messageInfo_Span_Tracestate_Entry.Size(m)
+}
+func (m *Span_Tracestate_Entry) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span_Tracestate_Entry.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span_Tracestate_Entry proto.InternalMessageInfo
+
+func (m *Span_Tracestate_Entry) GetKey() string {
+ if m != nil {
+ return m.Key
+ }
+ return ""
+}
+
+func (m *Span_Tracestate_Entry) GetValue() string {
+ if m != nil {
+ return m.Value
+ }
+ return ""
+}
+
+// A set of attributes, each with a key and a value.
+type Span_Attributes struct {
+ // The set of attributes. The value can be a string, an integer, or the
+ // Boolean values `true` and `false`. For example:
+ //
+ // "/instance_id": "my-instance"
+ // "/http/user_agent": ""
+ // "/http/server_latency": 300
+ // "abc.com/myattribute": true
+ AttributeMap map[string]*AttributeValue `protobuf:"bytes,1,rep,name=attribute_map,json=attributeMap,proto3" json:"attribute_map,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+ // The number of attributes that were discarded. Attributes can be discarded
+ // because their keys are too long or because there are too many attributes.
+ // If this value is 0, then no attributes were dropped.
+ DroppedAttributesCount int32 `protobuf:"varint,2,opt,name=dropped_attributes_count,json=droppedAttributesCount,proto3" json:"dropped_attributes_count,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span_Attributes) Reset() { *m = Span_Attributes{} }
+func (m *Span_Attributes) String() string { return proto.CompactTextString(m) }
+func (*Span_Attributes) ProtoMessage() {}
+func (*Span_Attributes) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 1}
+}
+
+func (m *Span_Attributes) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span_Attributes.Unmarshal(m, b)
+}
+func (m *Span_Attributes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span_Attributes.Marshal(b, m, deterministic)
+}
+func (m *Span_Attributes) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span_Attributes.Merge(m, src)
+}
+func (m *Span_Attributes) XXX_Size() int {
+ return xxx_messageInfo_Span_Attributes.Size(m)
+}
+func (m *Span_Attributes) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span_Attributes.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span_Attributes proto.InternalMessageInfo
+
+func (m *Span_Attributes) GetAttributeMap() map[string]*AttributeValue {
+ if m != nil {
+ return m.AttributeMap
+ }
+ return nil
+}
+
+func (m *Span_Attributes) GetDroppedAttributesCount() int32 {
+ if m != nil {
+ return m.DroppedAttributesCount
+ }
+ return 0
+}
+
+// A time-stamped annotation or message event in the Span.
+type Span_TimeEvent struct {
+ // The time the event occurred.
+ Time *timestamp.Timestamp `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
+ // A `TimeEvent` can contain either an `Annotation` object or a
+ // `MessageEvent` object, but not both.
+ //
+ // Types that are valid to be assigned to Value:
+ // *Span_TimeEvent_Annotation_
+ // *Span_TimeEvent_MessageEvent_
+ Value isSpan_TimeEvent_Value `protobuf_oneof:"value"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span_TimeEvent) Reset() { *m = Span_TimeEvent{} }
+func (m *Span_TimeEvent) String() string { return proto.CompactTextString(m) }
+func (*Span_TimeEvent) ProtoMessage() {}
+func (*Span_TimeEvent) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 2}
+}
+
+func (m *Span_TimeEvent) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span_TimeEvent.Unmarshal(m, b)
+}
+func (m *Span_TimeEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span_TimeEvent.Marshal(b, m, deterministic)
+}
+func (m *Span_TimeEvent) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span_TimeEvent.Merge(m, src)
+}
+func (m *Span_TimeEvent) XXX_Size() int {
+ return xxx_messageInfo_Span_TimeEvent.Size(m)
+}
+func (m *Span_TimeEvent) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span_TimeEvent.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span_TimeEvent proto.InternalMessageInfo
+
+func (m *Span_TimeEvent) GetTime() *timestamp.Timestamp {
+ if m != nil {
+ return m.Time
+ }
+ return nil
+}
+
+type isSpan_TimeEvent_Value interface {
+ isSpan_TimeEvent_Value()
+}
+
+type Span_TimeEvent_Annotation_ struct {
+ Annotation *Span_TimeEvent_Annotation `protobuf:"bytes,2,opt,name=annotation,proto3,oneof"`
+}
+
+type Span_TimeEvent_MessageEvent_ struct {
+ MessageEvent *Span_TimeEvent_MessageEvent `protobuf:"bytes,3,opt,name=message_event,json=messageEvent,proto3,oneof"`
+}
+
+func (*Span_TimeEvent_Annotation_) isSpan_TimeEvent_Value() {}
+
+func (*Span_TimeEvent_MessageEvent_) isSpan_TimeEvent_Value() {}
+
+func (m *Span_TimeEvent) GetValue() isSpan_TimeEvent_Value {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+func (m *Span_TimeEvent) GetAnnotation() *Span_TimeEvent_Annotation {
+ if x, ok := m.GetValue().(*Span_TimeEvent_Annotation_); ok {
+ return x.Annotation
+ }
+ return nil
+}
+
+func (m *Span_TimeEvent) GetMessageEvent() *Span_TimeEvent_MessageEvent {
+ if x, ok := m.GetValue().(*Span_TimeEvent_MessageEvent_); ok {
+ return x.MessageEvent
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Span_TimeEvent) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _Span_TimeEvent_OneofMarshaler, _Span_TimeEvent_OneofUnmarshaler, _Span_TimeEvent_OneofSizer, []interface{}{
+ (*Span_TimeEvent_Annotation_)(nil),
+ (*Span_TimeEvent_MessageEvent_)(nil),
+ }
+}
+
+func _Span_TimeEvent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*Span_TimeEvent)
+ // value
+ switch x := m.Value.(type) {
+ case *Span_TimeEvent_Annotation_:
+ b.EncodeVarint(2<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.Annotation); err != nil {
+ return err
+ }
+ case *Span_TimeEvent_MessageEvent_:
+ b.EncodeVarint(3<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.MessageEvent); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("Span_TimeEvent.Value has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _Span_TimeEvent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*Span_TimeEvent)
+ switch tag {
+ case 2: // value.annotation
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(Span_TimeEvent_Annotation)
+ err := b.DecodeMessage(msg)
+ m.Value = &Span_TimeEvent_Annotation_{msg}
+ return true, err
+ case 3: // value.message_event
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(Span_TimeEvent_MessageEvent)
+ err := b.DecodeMessage(msg)
+ m.Value = &Span_TimeEvent_MessageEvent_{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _Span_TimeEvent_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*Span_TimeEvent)
+ // value
+ switch x := m.Value.(type) {
+ case *Span_TimeEvent_Annotation_:
+ s := proto.Size(x.Annotation)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *Span_TimeEvent_MessageEvent_:
+ s := proto.Size(x.MessageEvent)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// A text annotation with a set of attributes.
+type Span_TimeEvent_Annotation struct {
+ // A user-supplied message describing the event.
+ Description *TruncatableString `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
+ // A set of attributes on the annotation.
+ Attributes *Span_Attributes `protobuf:"bytes,2,opt,name=attributes,proto3" json:"attributes,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span_TimeEvent_Annotation) Reset() { *m = Span_TimeEvent_Annotation{} }
+func (m *Span_TimeEvent_Annotation) String() string { return proto.CompactTextString(m) }
+func (*Span_TimeEvent_Annotation) ProtoMessage() {}
+func (*Span_TimeEvent_Annotation) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 2, 0}
+}
+
+func (m *Span_TimeEvent_Annotation) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span_TimeEvent_Annotation.Unmarshal(m, b)
+}
+func (m *Span_TimeEvent_Annotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span_TimeEvent_Annotation.Marshal(b, m, deterministic)
+}
+func (m *Span_TimeEvent_Annotation) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span_TimeEvent_Annotation.Merge(m, src)
+}
+func (m *Span_TimeEvent_Annotation) XXX_Size() int {
+ return xxx_messageInfo_Span_TimeEvent_Annotation.Size(m)
+}
+func (m *Span_TimeEvent_Annotation) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span_TimeEvent_Annotation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span_TimeEvent_Annotation proto.InternalMessageInfo
+
+func (m *Span_TimeEvent_Annotation) GetDescription() *TruncatableString {
+ if m != nil {
+ return m.Description
+ }
+ return nil
+}
+
+func (m *Span_TimeEvent_Annotation) GetAttributes() *Span_Attributes {
+ if m != nil {
+ return m.Attributes
+ }
+ return nil
+}
+
+// An event describing a message sent/received between Spans.
+type Span_TimeEvent_MessageEvent struct {
+ // The type of MessageEvent. Indicates whether the message was sent or
+ // received.
+ Type Span_TimeEvent_MessageEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=opencensus.proto.trace.v1.Span_TimeEvent_MessageEvent_Type" json:"type,omitempty"`
+ // An identifier for the MessageEvent's message that can be used to match
+ // SENT and RECEIVED MessageEvents. For example, this field could
+ // represent a sequence ID for a streaming RPC. It is recommended to be
+ // unique within a Span.
+ Id uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
+ // The number of uncompressed bytes sent or received.
+ UncompressedSize uint64 `protobuf:"varint,3,opt,name=uncompressed_size,json=uncompressedSize,proto3" json:"uncompressed_size,omitempty"`
+ // The number of compressed bytes sent or received. If zero, assumed to
+ // be the same size as uncompressed.
+ CompressedSize uint64 `protobuf:"varint,4,opt,name=compressed_size,json=compressedSize,proto3" json:"compressed_size,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span_TimeEvent_MessageEvent) Reset() { *m = Span_TimeEvent_MessageEvent{} }
+func (m *Span_TimeEvent_MessageEvent) String() string { return proto.CompactTextString(m) }
+func (*Span_TimeEvent_MessageEvent) ProtoMessage() {}
+func (*Span_TimeEvent_MessageEvent) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 2, 1}
+}
+
+func (m *Span_TimeEvent_MessageEvent) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span_TimeEvent_MessageEvent.Unmarshal(m, b)
+}
+func (m *Span_TimeEvent_MessageEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span_TimeEvent_MessageEvent.Marshal(b, m, deterministic)
+}
+func (m *Span_TimeEvent_MessageEvent) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span_TimeEvent_MessageEvent.Merge(m, src)
+}
+func (m *Span_TimeEvent_MessageEvent) XXX_Size() int {
+ return xxx_messageInfo_Span_TimeEvent_MessageEvent.Size(m)
+}
+func (m *Span_TimeEvent_MessageEvent) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span_TimeEvent_MessageEvent.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span_TimeEvent_MessageEvent proto.InternalMessageInfo
+
+func (m *Span_TimeEvent_MessageEvent) GetType() Span_TimeEvent_MessageEvent_Type {
+ if m != nil {
+ return m.Type
+ }
+ return Span_TimeEvent_MessageEvent_TYPE_UNSPECIFIED
+}
+
+func (m *Span_TimeEvent_MessageEvent) GetId() uint64 {
+ if m != nil {
+ return m.Id
+ }
+ return 0
+}
+
+func (m *Span_TimeEvent_MessageEvent) GetUncompressedSize() uint64 {
+ if m != nil {
+ return m.UncompressedSize
+ }
+ return 0
+}
+
+func (m *Span_TimeEvent_MessageEvent) GetCompressedSize() uint64 {
+ if m != nil {
+ return m.CompressedSize
+ }
+ return 0
+}
+
+// A collection of `TimeEvent`s. A `TimeEvent` is a time-stamped annotation
+// on the span, consisting of either user-supplied key-value pairs, or
+// details of a message sent/received between Spans.
+type Span_TimeEvents struct {
+ // A collection of `TimeEvent`s.
+ TimeEvent []*Span_TimeEvent `protobuf:"bytes,1,rep,name=time_event,json=timeEvent,proto3" json:"time_event,omitempty"`
+ // The number of dropped annotations in all the included time events.
+ // If the value is 0, then no annotations were dropped.
+ DroppedAnnotationsCount int32 `protobuf:"varint,2,opt,name=dropped_annotations_count,json=droppedAnnotationsCount,proto3" json:"dropped_annotations_count,omitempty"`
+ // The number of dropped message events in all the included time events.
+ // If the value is 0, then no message events were dropped.
+ DroppedMessageEventsCount int32 `protobuf:"varint,3,opt,name=dropped_message_events_count,json=droppedMessageEventsCount,proto3" json:"dropped_message_events_count,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span_TimeEvents) Reset() { *m = Span_TimeEvents{} }
+func (m *Span_TimeEvents) String() string { return proto.CompactTextString(m) }
+func (*Span_TimeEvents) ProtoMessage() {}
+func (*Span_TimeEvents) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 3}
+}
+
+func (m *Span_TimeEvents) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span_TimeEvents.Unmarshal(m, b)
+}
+func (m *Span_TimeEvents) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span_TimeEvents.Marshal(b, m, deterministic)
+}
+func (m *Span_TimeEvents) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span_TimeEvents.Merge(m, src)
+}
+func (m *Span_TimeEvents) XXX_Size() int {
+ return xxx_messageInfo_Span_TimeEvents.Size(m)
+}
+func (m *Span_TimeEvents) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span_TimeEvents.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span_TimeEvents proto.InternalMessageInfo
+
+func (m *Span_TimeEvents) GetTimeEvent() []*Span_TimeEvent {
+ if m != nil {
+ return m.TimeEvent
+ }
+ return nil
+}
+
+func (m *Span_TimeEvents) GetDroppedAnnotationsCount() int32 {
+ if m != nil {
+ return m.DroppedAnnotationsCount
+ }
+ return 0
+}
+
+func (m *Span_TimeEvents) GetDroppedMessageEventsCount() int32 {
+ if m != nil {
+ return m.DroppedMessageEventsCount
+ }
+ return 0
+}
+
+// A pointer from the current span to another span in the same trace or in a
+// different trace. For example, this can be used in batching operations,
+// where a single batch handler processes multiple requests from different
+// traces or when the handler receives a request from a different project.
+type Span_Link struct {
+ // A unique identifier for a trace. All spans from the same trace share
+ // the same `trace_id`. The ID is a 16-byte array.
+ TraceId []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
+ // A unique identifier for a span within a trace, assigned when the span
+ // is created. The ID is an 8-byte array.
+ SpanId []byte `protobuf:"bytes,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"`
+ // The relationship of the current span relative to the linked span.
+ Type Span_Link_Type `protobuf:"varint,3,opt,name=type,proto3,enum=opencensus.proto.trace.v1.Span_Link_Type" json:"type,omitempty"`
+ // A set of attributes on the link.
+ Attributes *Span_Attributes `protobuf:"bytes,4,opt,name=attributes,proto3" json:"attributes,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span_Link) Reset() { *m = Span_Link{} }
+func (m *Span_Link) String() string { return proto.CompactTextString(m) }
+func (*Span_Link) ProtoMessage() {}
+func (*Span_Link) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 4}
+}
+
+func (m *Span_Link) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span_Link.Unmarshal(m, b)
+}
+func (m *Span_Link) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span_Link.Marshal(b, m, deterministic)
+}
+func (m *Span_Link) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span_Link.Merge(m, src)
+}
+func (m *Span_Link) XXX_Size() int {
+ return xxx_messageInfo_Span_Link.Size(m)
+}
+func (m *Span_Link) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span_Link.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span_Link proto.InternalMessageInfo
+
+func (m *Span_Link) GetTraceId() []byte {
+ if m != nil {
+ return m.TraceId
+ }
+ return nil
+}
+
+func (m *Span_Link) GetSpanId() []byte {
+ if m != nil {
+ return m.SpanId
+ }
+ return nil
+}
+
+func (m *Span_Link) GetType() Span_Link_Type {
+ if m != nil {
+ return m.Type
+ }
+ return Span_Link_TYPE_UNSPECIFIED
+}
+
+func (m *Span_Link) GetAttributes() *Span_Attributes {
+ if m != nil {
+ return m.Attributes
+ }
+ return nil
+}
+
+// A collection of links, which are references from this span to a span
+// in the same or different trace.
+type Span_Links struct {
+ // A collection of links.
+ Link []*Span_Link `protobuf:"bytes,1,rep,name=link,proto3" json:"link,omitempty"`
+ // The number of dropped links after the maximum size was enforced. If
+ // this value is 0, then no links were dropped.
+ DroppedLinksCount int32 `protobuf:"varint,2,opt,name=dropped_links_count,json=droppedLinksCount,proto3" json:"dropped_links_count,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Span_Links) Reset() { *m = Span_Links{} }
+func (m *Span_Links) String() string { return proto.CompactTextString(m) }
+func (*Span_Links) ProtoMessage() {}
+func (*Span_Links) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{0, 5}
+}
+
+func (m *Span_Links) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Span_Links.Unmarshal(m, b)
+}
+func (m *Span_Links) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Span_Links.Marshal(b, m, deterministic)
+}
+func (m *Span_Links) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Span_Links.Merge(m, src)
+}
+func (m *Span_Links) XXX_Size() int {
+ return xxx_messageInfo_Span_Links.Size(m)
+}
+func (m *Span_Links) XXX_DiscardUnknown() {
+ xxx_messageInfo_Span_Links.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Span_Links proto.InternalMessageInfo
+
+func (m *Span_Links) GetLink() []*Span_Link {
+ if m != nil {
+ return m.Link
+ }
+ return nil
+}
+
+func (m *Span_Links) GetDroppedLinksCount() int32 {
+ if m != nil {
+ return m.DroppedLinksCount
+ }
+ return 0
+}
+
+// The `Status` type defines a logical error model that is suitable for different
+// programming environments, including REST APIs and RPC APIs. This proto's fields
+// are a subset of those of
+// [google.rpc.Status](https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto),
+// which is used by [gRPC](https://github.com/grpc).
+type Status struct {
+ // The status code.
+ Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
+ // A developer-facing error message, which should be in English.
+ Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Status) Reset() { *m = Status{} }
+func (m *Status) String() string { return proto.CompactTextString(m) }
+func (*Status) ProtoMessage() {}
+func (*Status) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{1}
+}
+
+func (m *Status) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Status.Unmarshal(m, b)
+}
+func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Status.Marshal(b, m, deterministic)
+}
+func (m *Status) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Status.Merge(m, src)
+}
+func (m *Status) XXX_Size() int {
+ return xxx_messageInfo_Status.Size(m)
+}
+func (m *Status) XXX_DiscardUnknown() {
+ xxx_messageInfo_Status.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Status proto.InternalMessageInfo
+
+func (m *Status) GetCode() int32 {
+ if m != nil {
+ return m.Code
+ }
+ return 0
+}
+
+func (m *Status) GetMessage() string {
+ if m != nil {
+ return m.Message
+ }
+ return ""
+}
+
+// The value of an Attribute.
+type AttributeValue struct {
+ // The type of the value.
+ //
+ // Types that are valid to be assigned to Value:
+ // *AttributeValue_StringValue
+ // *AttributeValue_IntValue
+ // *AttributeValue_BoolValue
+ // *AttributeValue_DoubleValue
+ Value isAttributeValue_Value `protobuf_oneof:"value"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *AttributeValue) Reset() { *m = AttributeValue{} }
+func (m *AttributeValue) String() string { return proto.CompactTextString(m) }
+func (*AttributeValue) ProtoMessage() {}
+func (*AttributeValue) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{2}
+}
+
+func (m *AttributeValue) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_AttributeValue.Unmarshal(m, b)
+}
+func (m *AttributeValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_AttributeValue.Marshal(b, m, deterministic)
+}
+func (m *AttributeValue) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AttributeValue.Merge(m, src)
+}
+func (m *AttributeValue) XXX_Size() int {
+ return xxx_messageInfo_AttributeValue.Size(m)
+}
+func (m *AttributeValue) XXX_DiscardUnknown() {
+ xxx_messageInfo_AttributeValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AttributeValue proto.InternalMessageInfo
+
+type isAttributeValue_Value interface {
+ isAttributeValue_Value()
+}
+
+type AttributeValue_StringValue struct {
+ StringValue *TruncatableString `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3,oneof"`
+}
+
+type AttributeValue_IntValue struct {
+ IntValue int64 `protobuf:"varint,2,opt,name=int_value,json=intValue,proto3,oneof"`
+}
+
+type AttributeValue_BoolValue struct {
+ BoolValue bool `protobuf:"varint,3,opt,name=bool_value,json=boolValue,proto3,oneof"`
+}
+
+type AttributeValue_DoubleValue struct {
+ DoubleValue float64 `protobuf:"fixed64,4,opt,name=double_value,json=doubleValue,proto3,oneof"`
+}
+
+func (*AttributeValue_StringValue) isAttributeValue_Value() {}
+
+func (*AttributeValue_IntValue) isAttributeValue_Value() {}
+
+func (*AttributeValue_BoolValue) isAttributeValue_Value() {}
+
+func (*AttributeValue_DoubleValue) isAttributeValue_Value() {}
+
+func (m *AttributeValue) GetValue() isAttributeValue_Value {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+func (m *AttributeValue) GetStringValue() *TruncatableString {
+ if x, ok := m.GetValue().(*AttributeValue_StringValue); ok {
+ return x.StringValue
+ }
+ return nil
+}
+
+func (m *AttributeValue) GetIntValue() int64 {
+ if x, ok := m.GetValue().(*AttributeValue_IntValue); ok {
+ return x.IntValue
+ }
+ return 0
+}
+
+func (m *AttributeValue) GetBoolValue() bool {
+ if x, ok := m.GetValue().(*AttributeValue_BoolValue); ok {
+ return x.BoolValue
+ }
+ return false
+}
+
+func (m *AttributeValue) GetDoubleValue() float64 {
+ if x, ok := m.GetValue().(*AttributeValue_DoubleValue); ok {
+ return x.DoubleValue
+ }
+ return 0
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*AttributeValue) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _AttributeValue_OneofMarshaler, _AttributeValue_OneofUnmarshaler, _AttributeValue_OneofSizer, []interface{}{
+ (*AttributeValue_StringValue)(nil),
+ (*AttributeValue_IntValue)(nil),
+ (*AttributeValue_BoolValue)(nil),
+ (*AttributeValue_DoubleValue)(nil),
+ }
+}
+
+func _AttributeValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*AttributeValue)
+ // value
+ switch x := m.Value.(type) {
+ case *AttributeValue_StringValue:
+ b.EncodeVarint(1<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.StringValue); err != nil {
+ return err
+ }
+ case *AttributeValue_IntValue:
+ b.EncodeVarint(2<<3 | proto.WireVarint)
+ b.EncodeVarint(uint64(x.IntValue))
+ case *AttributeValue_BoolValue:
+ t := uint64(0)
+ if x.BoolValue {
+ t = 1
+ }
+ b.EncodeVarint(3<<3 | proto.WireVarint)
+ b.EncodeVarint(t)
+ case *AttributeValue_DoubleValue:
+ b.EncodeVarint(4<<3 | proto.WireFixed64)
+ b.EncodeFixed64(math.Float64bits(x.DoubleValue))
+ case nil:
+ default:
+ return fmt.Errorf("AttributeValue.Value has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _AttributeValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*AttributeValue)
+ switch tag {
+ case 1: // value.string_value
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(TruncatableString)
+ err := b.DecodeMessage(msg)
+ m.Value = &AttributeValue_StringValue{msg}
+ return true, err
+ case 2: // value.int_value
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &AttributeValue_IntValue{int64(x)}
+ return true, err
+ case 3: // value.bool_value
+ if wire != proto.WireVarint {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeVarint()
+ m.Value = &AttributeValue_BoolValue{x != 0}
+ return true, err
+ case 4: // value.double_value
+ if wire != proto.WireFixed64 {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeFixed64()
+ m.Value = &AttributeValue_DoubleValue{math.Float64frombits(x)}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _AttributeValue_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*AttributeValue)
+ // value
+ switch x := m.Value.(type) {
+ case *AttributeValue_StringValue:
+ s := proto.Size(x.StringValue)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *AttributeValue_IntValue:
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(x.IntValue))
+ case *AttributeValue_BoolValue:
+ n += 1 // tag and wire
+ n += 1
+ case *AttributeValue_DoubleValue:
+ n += 1 // tag and wire
+ n += 8
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// The call stack which originated this span.
+type StackTrace struct {
+ // Stack frames in this stack trace.
+ StackFrames *StackTrace_StackFrames `protobuf:"bytes,1,opt,name=stack_frames,json=stackFrames,proto3" json:"stack_frames,omitempty"`
+ // The hash ID is used to conserve network bandwidth for duplicate
+ // stack traces within a single trace.
+ //
+ // Often multiple spans will have identical stack traces.
+ // The first occurrence of a stack trace should contain both
+ // `stack_frames` and a value in `stack_trace_hash_id`.
+ //
+ // Subsequent spans within the same request can refer
+ // to that stack trace by setting only `stack_trace_hash_id`.
+ //
+ // TODO: describe how to deal with the case where stack_trace_hash_id is
+ // zero because it was not set.
+ StackTraceHashId uint64 `protobuf:"varint,2,opt,name=stack_trace_hash_id,json=stackTraceHashId,proto3" json:"stack_trace_hash_id,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *StackTrace) Reset() { *m = StackTrace{} }
+func (m *StackTrace) String() string { return proto.CompactTextString(m) }
+func (*StackTrace) ProtoMessage() {}
+func (*StackTrace) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{3}
+}
+
+func (m *StackTrace) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_StackTrace.Unmarshal(m, b)
+}
+func (m *StackTrace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_StackTrace.Marshal(b, m, deterministic)
+}
+func (m *StackTrace) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_StackTrace.Merge(m, src)
+}
+func (m *StackTrace) XXX_Size() int {
+ return xxx_messageInfo_StackTrace.Size(m)
+}
+func (m *StackTrace) XXX_DiscardUnknown() {
+ xxx_messageInfo_StackTrace.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StackTrace proto.InternalMessageInfo
+
+func (m *StackTrace) GetStackFrames() *StackTrace_StackFrames {
+ if m != nil {
+ return m.StackFrames
+ }
+ return nil
+}
+
+func (m *StackTrace) GetStackTraceHashId() uint64 {
+ if m != nil {
+ return m.StackTraceHashId
+ }
+ return 0
+}
+
+// A single stack frame in a stack trace.
+type StackTrace_StackFrame struct {
+ // The fully-qualified name that uniquely identifies the function or
+ // method that is active in this frame.
+ FunctionName *TruncatableString `protobuf:"bytes,1,opt,name=function_name,json=functionName,proto3" json:"function_name,omitempty"`
+ // An un-mangled function name, if `function_name` is
+ // [mangled](http://www.avabodh.com/cxxin/namemangling.html). The name can
+ // be fully qualified.
+ OriginalFunctionName *TruncatableString `protobuf:"bytes,2,opt,name=original_function_name,json=originalFunctionName,proto3" json:"original_function_name,omitempty"`
+ // The name of the source file where the function call appears.
+ FileName *TruncatableString `protobuf:"bytes,3,opt,name=file_name,json=fileName,proto3" json:"file_name,omitempty"`
+ // The line number in `file_name` where the function call appears.
+ LineNumber int64 `protobuf:"varint,4,opt,name=line_number,json=lineNumber,proto3" json:"line_number,omitempty"`
+ // The column number where the function call appears, if available.
+ // This is important in JavaScript because of its anonymous functions.
+ ColumnNumber int64 `protobuf:"varint,5,opt,name=column_number,json=columnNumber,proto3" json:"column_number,omitempty"`
+ // The binary module from where the code was loaded.
+ LoadModule *Module `protobuf:"bytes,6,opt,name=load_module,json=loadModule,proto3" json:"load_module,omitempty"`
+ // The version of the deployed source code.
+ SourceVersion *TruncatableString `protobuf:"bytes,7,opt,name=source_version,json=sourceVersion,proto3" json:"source_version,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *StackTrace_StackFrame) Reset() { *m = StackTrace_StackFrame{} }
+func (m *StackTrace_StackFrame) String() string { return proto.CompactTextString(m) }
+func (*StackTrace_StackFrame) ProtoMessage() {}
+func (*StackTrace_StackFrame) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{3, 0}
+}
+
+func (m *StackTrace_StackFrame) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_StackTrace_StackFrame.Unmarshal(m, b)
+}
+func (m *StackTrace_StackFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_StackTrace_StackFrame.Marshal(b, m, deterministic)
+}
+func (m *StackTrace_StackFrame) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_StackTrace_StackFrame.Merge(m, src)
+}
+func (m *StackTrace_StackFrame) XXX_Size() int {
+ return xxx_messageInfo_StackTrace_StackFrame.Size(m)
+}
+func (m *StackTrace_StackFrame) XXX_DiscardUnknown() {
+ xxx_messageInfo_StackTrace_StackFrame.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StackTrace_StackFrame proto.InternalMessageInfo
+
+func (m *StackTrace_StackFrame) GetFunctionName() *TruncatableString {
+ if m != nil {
+ return m.FunctionName
+ }
+ return nil
+}
+
+func (m *StackTrace_StackFrame) GetOriginalFunctionName() *TruncatableString {
+ if m != nil {
+ return m.OriginalFunctionName
+ }
+ return nil
+}
+
+func (m *StackTrace_StackFrame) GetFileName() *TruncatableString {
+ if m != nil {
+ return m.FileName
+ }
+ return nil
+}
+
+func (m *StackTrace_StackFrame) GetLineNumber() int64 {
+ if m != nil {
+ return m.LineNumber
+ }
+ return 0
+}
+
+func (m *StackTrace_StackFrame) GetColumnNumber() int64 {
+ if m != nil {
+ return m.ColumnNumber
+ }
+ return 0
+}
+
+func (m *StackTrace_StackFrame) GetLoadModule() *Module {
+ if m != nil {
+ return m.LoadModule
+ }
+ return nil
+}
+
+func (m *StackTrace_StackFrame) GetSourceVersion() *TruncatableString {
+ if m != nil {
+ return m.SourceVersion
+ }
+ return nil
+}
+
+// A collection of stack frames, which can be truncated.
+type StackTrace_StackFrames struct {
+ // Stack frames in this call stack.
+ Frame []*StackTrace_StackFrame `protobuf:"bytes,1,rep,name=frame,proto3" json:"frame,omitempty"`
+ // The number of stack frames that were dropped because there
+ // were too many stack frames.
+ // If this value is 0, then no stack frames were dropped.
+ DroppedFramesCount int32 `protobuf:"varint,2,opt,name=dropped_frames_count,json=droppedFramesCount,proto3" json:"dropped_frames_count,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *StackTrace_StackFrames) Reset() { *m = StackTrace_StackFrames{} }
+func (m *StackTrace_StackFrames) String() string { return proto.CompactTextString(m) }
+func (*StackTrace_StackFrames) ProtoMessage() {}
+func (*StackTrace_StackFrames) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{3, 1}
+}
+
+func (m *StackTrace_StackFrames) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_StackTrace_StackFrames.Unmarshal(m, b)
+}
+func (m *StackTrace_StackFrames) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_StackTrace_StackFrames.Marshal(b, m, deterministic)
+}
+func (m *StackTrace_StackFrames) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_StackTrace_StackFrames.Merge(m, src)
+}
+func (m *StackTrace_StackFrames) XXX_Size() int {
+ return xxx_messageInfo_StackTrace_StackFrames.Size(m)
+}
+func (m *StackTrace_StackFrames) XXX_DiscardUnknown() {
+ xxx_messageInfo_StackTrace_StackFrames.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StackTrace_StackFrames proto.InternalMessageInfo
+
+func (m *StackTrace_StackFrames) GetFrame() []*StackTrace_StackFrame {
+ if m != nil {
+ return m.Frame
+ }
+ return nil
+}
+
+func (m *StackTrace_StackFrames) GetDroppedFramesCount() int32 {
+ if m != nil {
+ return m.DroppedFramesCount
+ }
+ return 0
+}
+
+// A description of a binary module.
+type Module struct {
+ // TODO: document the meaning of this field.
+ // For example: main binary, kernel modules, and dynamic libraries
+ // such as libc.so, sharedlib.so.
+ Module *TruncatableString `protobuf:"bytes,1,opt,name=module,proto3" json:"module,omitempty"`
+ // A unique identifier for the module, usually a hash of its
+ // contents.
+ BuildId *TruncatableString `protobuf:"bytes,2,opt,name=build_id,json=buildId,proto3" json:"build_id,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Module) Reset() { *m = Module{} }
+func (m *Module) String() string { return proto.CompactTextString(m) }
+func (*Module) ProtoMessage() {}
+func (*Module) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{4}
+}
+
+func (m *Module) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Module.Unmarshal(m, b)
+}
+func (m *Module) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Module.Marshal(b, m, deterministic)
+}
+func (m *Module) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Module.Merge(m, src)
+}
+func (m *Module) XXX_Size() int {
+ return xxx_messageInfo_Module.Size(m)
+}
+func (m *Module) XXX_DiscardUnknown() {
+ xxx_messageInfo_Module.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Module proto.InternalMessageInfo
+
+func (m *Module) GetModule() *TruncatableString {
+ if m != nil {
+ return m.Module
+ }
+ return nil
+}
+
+func (m *Module) GetBuildId() *TruncatableString {
+ if m != nil {
+ return m.BuildId
+ }
+ return nil
+}
+
+// A string that might be shortened to a specified length.
+type TruncatableString struct {
+ // The shortened string. For example, if the original string was 500 bytes long and
+ // the limit of the string was 128 bytes, then this value contains the first 128
+ // bytes of the 500-byte string. Note that truncation always happens on a
+ // character boundary, to ensure that a truncated string is still valid UTF-8.
+ // Because it may contain multi-byte characters, the size of the truncated string
+ // may be less than the truncation limit.
+ Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+ // The number of bytes removed from the original string. If this
+ // value is 0, then the string was not shortened.
+ TruncatedByteCount int32 `protobuf:"varint,2,opt,name=truncated_byte_count,json=truncatedByteCount,proto3" json:"truncated_byte_count,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *TruncatableString) Reset() { *m = TruncatableString{} }
+func (m *TruncatableString) String() string { return proto.CompactTextString(m) }
+func (*TruncatableString) ProtoMessage() {}
+func (*TruncatableString) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8ea38bbb821bf584, []int{5}
+}
+
+func (m *TruncatableString) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_TruncatableString.Unmarshal(m, b)
+}
+func (m *TruncatableString) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_TruncatableString.Marshal(b, m, deterministic)
+}
+func (m *TruncatableString) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TruncatableString.Merge(m, src)
+}
+func (m *TruncatableString) XXX_Size() int {
+ return xxx_messageInfo_TruncatableString.Size(m)
+}
+func (m *TruncatableString) XXX_DiscardUnknown() {
+ xxx_messageInfo_TruncatableString.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TruncatableString proto.InternalMessageInfo
+
+func (m *TruncatableString) GetValue() string {
+ if m != nil {
+ return m.Value
+ }
+ return ""
+}
+
+func (m *TruncatableString) GetTruncatedByteCount() int32 {
+ if m != nil {
+ return m.TruncatedByteCount
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterEnum("opencensus.proto.trace.v1.Span_SpanKind", Span_SpanKind_name, Span_SpanKind_value)
+ proto.RegisterEnum("opencensus.proto.trace.v1.Span_TimeEvent_MessageEvent_Type", Span_TimeEvent_MessageEvent_Type_name, Span_TimeEvent_MessageEvent_Type_value)
+ proto.RegisterEnum("opencensus.proto.trace.v1.Span_Link_Type", Span_Link_Type_name, Span_Link_Type_value)
+ proto.RegisterType((*Span)(nil), "opencensus.proto.trace.v1.Span")
+ proto.RegisterType((*Span_Tracestate)(nil), "opencensus.proto.trace.v1.Span.Tracestate")
+ proto.RegisterType((*Span_Tracestate_Entry)(nil), "opencensus.proto.trace.v1.Span.Tracestate.Entry")
+ proto.RegisterType((*Span_Attributes)(nil), "opencensus.proto.trace.v1.Span.Attributes")
+ proto.RegisterMapType((map[string]*AttributeValue)(nil), "opencensus.proto.trace.v1.Span.Attributes.AttributeMapEntry")
+ proto.RegisterType((*Span_TimeEvent)(nil), "opencensus.proto.trace.v1.Span.TimeEvent")
+ proto.RegisterType((*Span_TimeEvent_Annotation)(nil), "opencensus.proto.trace.v1.Span.TimeEvent.Annotation")
+ proto.RegisterType((*Span_TimeEvent_MessageEvent)(nil), "opencensus.proto.trace.v1.Span.TimeEvent.MessageEvent")
+ proto.RegisterType((*Span_TimeEvents)(nil), "opencensus.proto.trace.v1.Span.TimeEvents")
+ proto.RegisterType((*Span_Link)(nil), "opencensus.proto.trace.v1.Span.Link")
+ proto.RegisterType((*Span_Links)(nil), "opencensus.proto.trace.v1.Span.Links")
+ proto.RegisterType((*Status)(nil), "opencensus.proto.trace.v1.Status")
+ proto.RegisterType((*AttributeValue)(nil), "opencensus.proto.trace.v1.AttributeValue")
+ proto.RegisterType((*StackTrace)(nil), "opencensus.proto.trace.v1.StackTrace")
+ proto.RegisterType((*StackTrace_StackFrame)(nil), "opencensus.proto.trace.v1.StackTrace.StackFrame")
+ proto.RegisterType((*StackTrace_StackFrames)(nil), "opencensus.proto.trace.v1.StackTrace.StackFrames")
+ proto.RegisterType((*Module)(nil), "opencensus.proto.trace.v1.Module")
+ proto.RegisterType((*TruncatableString)(nil), "opencensus.proto.trace.v1.TruncatableString")
+}
+
+func init() {
+ proto.RegisterFile("opencensus/proto/trace/v1/trace.proto", fileDescriptor_8ea38bbb821bf584)
+}
+
+var fileDescriptor_8ea38bbb821bf584 = []byte{
+ // 1524 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0x5b, 0x6f, 0x1b, 0xb7,
+ 0x12, 0xf6, 0xea, 0xae, 0x91, 0xac, 0xc8, 0x8c, 0x93, 0xc8, 0x3a, 0x39, 0x27, 0x3e, 0x4a, 0x82,
+ 0xe3, 0x9c, 0xd6, 0x72, 0xe2, 0xa4, 0x41, 0xae, 0x48, 0x7d, 0x91, 0x2b, 0xc5, 0x8e, 0xaa, 0x50,
+ 0x8a, 0xd1, 0x0b, 0x8a, 0xc5, 0x4a, 0x4b, 0xcb, 0x5b, 0x4b, 0xdc, 0xed, 0x92, 0xeb, 0xc2, 0x79,
+ 0xeb, 0x53, 0x51, 0xf4, 0xad, 0x40, 0xd1, 0x3f, 0xd0, 0x87, 0xfe, 0x9d, 0xa2, 0xbf, 0xa3, 0xbf,
+ 0xa0, 0x2f, 0x05, 0xc9, 0xbd, 0xc9, 0x49, 0x6c, 0x55, 0x79, 0x31, 0xb8, 0xe4, 0x7c, 0x1f, 0x39,
+ 0x9c, 0x6f, 0x86, 0x63, 0xc1, 0x4d, 0xdb, 0x21, 0x74, 0x40, 0x28, 0xf3, 0xd8, 0x9a, 0xe3, 0xda,
+ 0xdc, 0x5e, 0xe3, 0xae, 0x31, 0x20, 0x6b, 0xc7, 0x77, 0xd4, 0xa0, 0x2e, 0x27, 0xd1, 0x52, 0x64,
+ 0xa6, 0x66, 0xea, 0x6a, 0xf5, 0xf8, 0x4e, 0xf5, 0xda, 0xd0, 0xb6, 0x87, 0x23, 0xa2, 0xd0, 0x7d,
+ 0xef, 0x60, 0x8d, 0x5b, 0x63, 0xc2, 0xb8, 0x31, 0x76, 0x94, 0x65, 0xf5, 0x3f, 0xa7, 0x0d, 0xbe,
+ 0x75, 0x0d, 0xc7, 0x21, 0xae, 0xcf, 0x54, 0xfb, 0xee, 0x12, 0xa4, 0xba, 0x8e, 0x41, 0xd1, 0x12,
+ 0xe4, 0x24, 0xab, 0x6e, 0x99, 0x15, 0x6d, 0x59, 0x5b, 0x29, 0xe2, 0xac, 0xfc, 0x6e, 0x99, 0xe8,
+ 0x0a, 0x64, 0x99, 0x63, 0x50, 0xb1, 0x92, 0x90, 0x2b, 0x19, 0xf1, 0xd9, 0x32, 0xd1, 0x73, 0x00,
+ 0x69, 0xc3, 0xb8, 0xc1, 0x49, 0xe5, 0xc2, 0xb2, 0xb6, 0x52, 0x58, 0xff, 0x7f, 0xfd, 0x9d, 0xa7,
+ 0xad, 0x8b, 0x8d, 0xea, 0xbd, 0x10, 0x81, 0x63, 0x68, 0x74, 0x03, 0x4a, 0x8e, 0xe1, 0x12, 0xca,
+ 0xf5, 0x60, 0xaf, 0xa4, 0xdc, 0xab, 0xa8, 0x66, 0xbb, 0x6a, 0xc7, 0x8f, 0x21, 0x45, 0x8d, 0x31,
+ 0xa9, 0xa4, 0xe4, 0x5e, 0x1f, 0x9e, 0xb1, 0x57, 0xcf, 0xf5, 0xe8, 0xc0, 0xe0, 0x46, 0x7f, 0x44,
+ 0xba, 0xdc, 0xb5, 0xe8, 0x10, 0x4b, 0x24, 0x7a, 0x02, 0xa9, 0x23, 0x8b, 0x9a, 0x95, 0xd2, 0xb2,
+ 0xb6, 0x52, 0x5a, 0x5f, 0x39, 0xef, 0xb4, 0xe2, 0xcf, 0xae, 0x45, 0x4d, 0x2c, 0x51, 0xe8, 0x21,
+ 0x00, 0xe3, 0x86, 0xcb, 0x75, 0x71, 0xcf, 0x95, 0xb4, 0x3c, 0x45, 0xb5, 0xae, 0xee, 0xb8, 0x1e,
+ 0xdc, 0x71, 0xbd, 0x17, 0x04, 0x01, 0xe7, 0xa5, 0xb5, 0xf8, 0x46, 0x1f, 0x41, 0x8e, 0x50, 0x53,
+ 0x01, 0x33, 0xe7, 0x02, 0xb3, 0x84, 0x9a, 0x12, 0xf6, 0x1c, 0xc0, 0xe0, 0xdc, 0xb5, 0xfa, 0x1e,
+ 0x27, 0xac, 0x92, 0x9d, 0xee, 0x8e, 0x37, 0x42, 0x04, 0x8e, 0xa1, 0xd1, 0x0e, 0x14, 0x18, 0x37,
+ 0x06, 0x47, 0xba, 0xb4, 0xae, 0xe4, 0x24, 0xd9, 0xcd, 0xb3, 0xc8, 0x84, 0xb5, 0x0c, 0x18, 0x06,
+ 0x16, 0x8e, 0xd1, 0x2e, 0x14, 0x84, 0x1b, 0x3a, 0x39, 0x26, 0x94, 0xb3, 0x4a, 0x7e, 0xca, 0xc0,
+ 0x5b, 0x63, 0xd2, 0x90, 0x08, 0x0c, 0x3c, 0x1c, 0xa3, 0xc7, 0x90, 0x1e, 0x59, 0xf4, 0x88, 0x55,
+ 0xe0, 0xfc, 0xe3, 0x08, 0x9a, 0x3d, 0x61, 0x8c, 0x15, 0x06, 0x3d, 0x84, 0x8c, 0x90, 0x8f, 0xc7,
+ 0x2a, 0x05, 0x89, 0xfe, 0xef, 0xd9, 0xce, 0x70, 0x8f, 0x61, 0x1f, 0x80, 0x3e, 0x83, 0x7f, 0x31,
+ 0x63, 0x4c, 0x74, 0xc7, 0xb5, 0x07, 0x84, 0x31, 0xdd, 0x60, 0x7a, 0x4c, 0x80, 0x95, 0xe2, 0x3b,
+ 0x42, 0xb4, 0x69, 0xdb, 0xa3, 0x7d, 0x63, 0xe4, 0x11, 0x7c, 0x45, 0xc0, 0x3b, 0x0a, 0xbd, 0xc1,
+ 0x3a, 0xa1, 0x4c, 0xd1, 0x0e, 0x94, 0x07, 0x87, 0xd6, 0xc8, 0x54, 0x4a, 0x1e, 0xd8, 0x1e, 0xe5,
+ 0x95, 0x79, 0x49, 0x77, 0xf5, 0x0d, 0xba, 0x57, 0x2d, 0xca, 0xef, 0xae, 0x2b, 0xc2, 0x92, 0x44,
+ 0x09, 0x8a, 0x2d, 0x81, 0xa9, 0xfe, 0xa0, 0x01, 0x44, 0xd9, 0x82, 0x9e, 0x43, 0x96, 0x50, 0xee,
+ 0x5a, 0x84, 0x55, 0xb4, 0xe5, 0xe4, 0x4a, 0x61, 0xfd, 0xf6, 0xf4, 0xa9, 0x56, 0x6f, 0x50, 0xee,
+ 0x9e, 0xe0, 0x80, 0xa0, 0xba, 0x06, 0x69, 0x39, 0x83, 0xca, 0x90, 0x3c, 0x22, 0x27, 0x32, 0xe3,
+ 0xf3, 0x58, 0x0c, 0xd1, 0x22, 0xa4, 0x8f, 0xc5, 0x71, 0x64, 0xae, 0xe7, 0xb1, 0xfa, 0xa8, 0xfe,
+ 0x9c, 0x00, 0x88, 0x54, 0x85, 0x0c, 0x98, 0x0f, 0x75, 0xa5, 0x8f, 0x0d, 0xc7, 0x3f, 0xd1, 0x93,
+ 0xe9, 0x85, 0x19, 0x0d, 0x5f, 0x18, 0x8e, 0x3a, 0x5d, 0xd1, 0x88, 0x4d, 0xa1, 0x07, 0x50, 0x31,
+ 0x5d, 0xdb, 0x71, 0x88, 0xa9, 0x47, 0x12, 0xf6, 0x6f, 0x53, 0x1c, 0x2d, 0x8d, 0x2f, 0xfb, 0xeb,
+ 0x11, 0xa9, 0xba, 0xb7, 0xaf, 0x61, 0xe1, 0x0d, 0xf2, 0xb7, 0x38, 0xfa, 0x2c, 0xee, 0x68, 0x61,
+ 0xfd, 0xd6, 0x19, 0x67, 0x0f, 0xe9, 0x54, 0xa0, 0x14, 0xee, 0x51, 0xe2, 0x81, 0x56, 0xfd, 0x35,
+ 0x0d, 0xf9, 0x50, 0xd8, 0xa8, 0x0e, 0x29, 0x99, 0xdf, 0xda, 0xb9, 0xf9, 0x2d, 0xed, 0xd0, 0x3e,
+ 0x80, 0x41, 0xa9, 0xcd, 0x0d, 0x6e, 0xd9, 0xd4, 0x3f, 0xc7, 0xbd, 0xa9, 0xf3, 0xa8, 0xbe, 0x11,
+ 0x62, 0x9b, 0x73, 0x38, 0xc6, 0x84, 0xbe, 0x82, 0xf9, 0x31, 0x61, 0xcc, 0x18, 0xfa, 0x39, 0x2a,
+ 0x6b, 0x69, 0x61, 0xfd, 0xfe, 0xf4, 0xd4, 0x2f, 0x14, 0x5c, 0x7e, 0x34, 0xe7, 0x70, 0x71, 0x1c,
+ 0xfb, 0xae, 0xfe, 0xa6, 0x01, 0x44, 0x7b, 0xa3, 0x36, 0x14, 0x4c, 0xc2, 0x06, 0xae, 0xe5, 0x48,
+ 0x37, 0xb4, 0x19, 0x6a, 0x73, 0x9c, 0xe0, 0x54, 0xc9, 0x4b, 0xbc, 0x4f, 0xc9, 0xab, 0xfe, 0xa5,
+ 0x41, 0x31, 0xee, 0x0b, 0xfa, 0x14, 0x52, 0xfc, 0xc4, 0x51, 0x21, 0x2a, 0xad, 0x3f, 0x9e, 0xed,
+ 0x46, 0xea, 0xbd, 0x13, 0x87, 0x60, 0x49, 0x84, 0x4a, 0x90, 0xf0, 0x1f, 0xc6, 0x14, 0x4e, 0x58,
+ 0x26, 0xfa, 0x00, 0x16, 0x3c, 0x3a, 0xb0, 0xc7, 0x8e, 0x4b, 0x18, 0x23, 0xa6, 0xce, 0xac, 0xd7,
+ 0x44, 0xde, 0x7f, 0x0a, 0x97, 0xe3, 0x0b, 0x5d, 0xeb, 0x35, 0x41, 0xff, 0x83, 0x0b, 0xa7, 0x4d,
+ 0x53, 0xd2, 0xb4, 0x34, 0x69, 0x58, 0xbb, 0x07, 0x29, 0xb1, 0x27, 0x5a, 0x84, 0x72, 0xef, 0xf3,
+ 0x4e, 0x43, 0x7f, 0xd5, 0xee, 0x76, 0x1a, 0x5b, 0xad, 0x9d, 0x56, 0x63, 0xbb, 0x3c, 0x87, 0x72,
+ 0x90, 0xea, 0x36, 0xda, 0xbd, 0xb2, 0x86, 0x8a, 0x90, 0xc3, 0x8d, 0xad, 0x46, 0x6b, 0xbf, 0xb1,
+ 0x5d, 0x4e, 0x6c, 0x66, 0x7d, 0x89, 0x57, 0xff, 0x10, 0xa5, 0x24, 0xaa, 0xb9, 0x4d, 0x80, 0xa8,
+ 0x80, 0xfb, 0xb9, 0x7b, 0x6b, 0xea, 0xab, 0xc0, 0xf9, 0xb0, 0x7c, 0xa3, 0x47, 0xb0, 0x14, 0x66,
+ 0x69, 0xa8, 0x88, 0xc9, 0x34, 0xbd, 0x12, 0xa4, 0x69, 0xb4, 0x2e, 0xf3, 0x14, 0x3d, 0x83, 0xab,
+ 0x01, 0x76, 0x42, 0xad, 0x01, 0x3c, 0x29, 0xe1, 0x01, 0x7f, 0xfc, 0xfe, 0xfd, 0x44, 0xff, 0x29,
+ 0x01, 0x29, 0xf1, 0x1c, 0xcc, 0xd4, 0xbc, 0x3c, 0xf5, 0x85, 0x90, 0x94, 0x42, 0xb8, 0x35, 0xcd,
+ 0xb3, 0x13, 0x0f, 0xfb, 0xa4, 0x48, 0x53, 0xef, 0x23, 0xd2, 0xda, 0xee, 0x99, 0xc1, 0xbd, 0x04,
+ 0x0b, 0x5b, 0xcd, 0xd6, 0xde, 0xb6, 0xbe, 0xd7, 0x6a, 0xef, 0x36, 0xb6, 0xf5, 0x6e, 0x67, 0xa3,
+ 0x5d, 0xd6, 0xd0, 0x65, 0x40, 0x9d, 0x0d, 0xdc, 0x68, 0xf7, 0x26, 0xe6, 0x13, 0xd5, 0x6f, 0x20,
+ 0x2d, 0x9f, 0x48, 0xf4, 0x00, 0x52, 0xe2, 0x91, 0xf4, 0xc3, 0x7b, 0x63, 0x1a, 0x07, 0xb1, 0x44,
+ 0xa0, 0x3a, 0x5c, 0x0c, 0x02, 0x23, 0x9f, 0xd9, 0x89, 0x70, 0x2e, 0xf8, 0x4b, 0x72, 0x13, 0x19,
+ 0x87, 0xda, 0x53, 0xc8, 0x05, 0x7d, 0x12, 0x5a, 0x82, 0x4b, 0xe2, 0x20, 0xfa, 0x6e, 0xab, 0xbd,
+ 0x7d, 0xca, 0x11, 0x80, 0x4c, 0xb7, 0x81, 0xf7, 0x1b, 0xb8, 0xac, 0x89, 0xf1, 0xd6, 0x5e, 0x4b,
+ 0x68, 0x36, 0x51, 0xbb, 0x0f, 0x19, 0xf5, 0x36, 0x23, 0x04, 0xa9, 0x81, 0x6d, 0xaa, 0xe4, 0x4c,
+ 0x63, 0x39, 0x46, 0x15, 0xc8, 0xfa, 0xea, 0xf0, 0x5f, 0xa4, 0xe0, 0xb3, 0xf6, 0xbb, 0x06, 0xa5,
+ 0xc9, 0xca, 0x8c, 0x5e, 0x42, 0x91, 0xc9, 0x8a, 0xa2, 0xab, 0xd2, 0x3e, 0x43, 0x2d, 0x6a, 0xce,
+ 0xe1, 0x82, 0xe2, 0x50, 0x94, 0xff, 0x86, 0xbc, 0x45, 0xb9, 0x1e, 0x3d, 0x15, 0xc9, 0xe6, 0x1c,
+ 0xce, 0x59, 0x94, 0xab, 0xe5, 0x6b, 0x00, 0x7d, 0xdb, 0x1e, 0xf9, 0xeb, 0x42, 0x4c, 0xb9, 0xe6,
+ 0x1c, 0xce, 0xf7, 0x83, 0x36, 0x01, 0x5d, 0x87, 0xa2, 0x69, 0x7b, 0xfd, 0x11, 0xf1, 0x4d, 0x84,
+ 0x54, 0x34, 0xb1, 0x89, 0x9a, 0x95, 0x46, 0x61, 0xa2, 0xd6, 0x7e, 0xcc, 0x00, 0x44, 0x5d, 0x17,
+ 0xea, 0x09, 0x7f, 0x44, 0xc7, 0x76, 0xe0, 0x1a, 0x63, 0xf9, 0xf0, 0x0b, 0x7f, 0xee, 0x4c, 0xd5,
+ 0xb2, 0xa9, 0xe1, 0x8e, 0x04, 0x62, 0xd5, 0xf8, 0xa9, 0x0f, 0xb4, 0x0a, 0x17, 0x63, 0x7d, 0xa0,
+ 0x7e, 0x68, 0xb0, 0x43, 0x3d, 0xac, 0x61, 0xe5, 0xa8, 0xd1, 0x6b, 0x1a, 0xec, 0xb0, 0x65, 0x56,
+ 0xff, 0x4c, 0xfa, 0x67, 0x92, 0x70, 0xf4, 0x12, 0xe6, 0x0f, 0x3c, 0x3a, 0x10, 0x89, 0xac, 0xcb,
+ 0x66, 0x7c, 0x96, 0x82, 0x5f, 0x0c, 0x28, 0xda, 0x82, 0xb2, 0x0f, 0x97, 0x6d, 0xd7, 0x1a, 0x5a,
+ 0xd4, 0x18, 0xe9, 0x93, 0xdc, 0x89, 0x19, 0xb8, 0x17, 0x03, 0xae, 0x9d, 0xf8, 0x1e, 0x2d, 0xc8,
+ 0x1f, 0x58, 0x23, 0xa2, 0x68, 0x93, 0x33, 0xd0, 0xe6, 0x04, 0x5c, 0x52, 0x5d, 0x83, 0xc2, 0xc8,
+ 0xa2, 0x44, 0xa7, 0xde, 0xb8, 0x4f, 0x5c, 0x19, 0xd1, 0x24, 0x06, 0x31, 0xd5, 0x96, 0x33, 0xe8,
+ 0x3a, 0xcc, 0x0f, 0xec, 0x91, 0x37, 0xa6, 0x81, 0x49, 0x5a, 0x9a, 0x14, 0xd5, 0xa4, 0x6f, 0xb4,
+ 0x09, 0x85, 0x91, 0x6d, 0x98, 0xfa, 0xd8, 0x36, 0xbd, 0x51, 0xf0, 0x3f, 0xc1, 0x59, 0x0d, 0xec,
+ 0x0b, 0x69, 0x88, 0x41, 0xa0, 0xd4, 0x18, 0x75, 0xa1, 0xc4, 0x6c, 0xcf, 0x1d, 0x10, 0xfd, 0x98,
+ 0xb8, 0x4c, 0xbc, 0xbe, 0xd9, 0x19, 0x3c, 0x9b, 0x57, 0x1c, 0xfb, 0x8a, 0xa2, 0xfa, 0xbd, 0x06,
+ 0x85, 0x98, 0x76, 0xd0, 0x0e, 0xa4, 0xa5, 0xfc, 0xa6, 0x69, 0x3b, 0xdf, 0xa6, 0x3e, 0xac, 0xe0,
+ 0xe8, 0x36, 0x2c, 0x06, 0x65, 0x45, 0xc9, 0x79, 0xa2, 0xae, 0x20, 0x7f, 0x4d, 0x6d, 0xaa, 0x0a,
+ 0xcb, 0x2f, 0x1a, 0x64, 0x7c, 0x4f, 0xb7, 0x21, 0xe3, 0x5f, 0xd4, 0x2c, 0x72, 0xf3, 0xb1, 0xe8,
+ 0x13, 0xc8, 0xf5, 0x3d, 0xd1, 0x9a, 0xfb, 0x72, 0xff, 0xa7, 0x3c, 0x59, 0x89, 0x6e, 0x99, 0xb5,
+ 0x2f, 0x61, 0xe1, 0x8d, 0xd5, 0xa8, 0x75, 0xd6, 0x62, 0xad, 0xb3, 0x70, 0x9b, 0x2b, 0x53, 0x62,
+ 0xea, 0xfd, 0x13, 0x4e, 0x26, 0xdd, 0x0e, 0xd7, 0x36, 0x4f, 0x38, 0x91, 0x6e, 0x6f, 0x3a, 0x70,
+ 0xd5, 0xb2, 0xdf, 0x7d, 0xae, 0x4d, 0xf5, 0x5f, 0x41, 0x47, 0x4c, 0x76, 0xb4, 0x2f, 0x36, 0x87,
+ 0x16, 0x3f, 0xf4, 0xfa, 0xf5, 0x81, 0x3d, 0x5e, 0x53, 0xf6, 0xab, 0x16, 0x65, 0xdc, 0xf5, 0xc6,
+ 0x84, 0xaa, 0xf7, 0x76, 0x2d, 0xa2, 0x5a, 0x55, 0xbf, 0x33, 0x0c, 0x09, 0x5d, 0x1d, 0x46, 0x3f,
+ 0x37, 0xf4, 0x33, 0x72, 0xfa, 0xee, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb1, 0x5e, 0xa6, 0x6a,
+ 0x92, 0x10, 0x00, 0x00,
+}
diff --git a/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1/trace_config.pb.go b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1/trace_config.pb.go
new file mode 100644
index 0000000000..929e8995bb
--- /dev/null
+++ b/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1/trace_config.pb.go
@@ -0,0 +1,406 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: opencensus/proto/trace/v1/trace_config.proto
+
+package v1
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Global configuration of the trace service.
+type TraceConfig struct {
+ // The global default sampler used to make decisions on span sampling.
+ //
+ // Types that are valid to be assigned to Sampler:
+ // *TraceConfig_ProbabilitySampler
+ // *TraceConfig_ConstantSampler
+ // *TraceConfig_RateLimitingSampler
+ Sampler isTraceConfig_Sampler `protobuf_oneof:"sampler"`
+ // The global default max number of attributes per span.
+ MaxNumberOfAttributes int64 `protobuf:"varint,4,opt,name=max_number_of_attributes,json=maxNumberOfAttributes,proto3" json:"max_number_of_attributes,omitempty"`
+ // The global default max number of annotation events per span.
+ MaxNumberOfAnnotations int64 `protobuf:"varint,5,opt,name=max_number_of_annotations,json=maxNumberOfAnnotations,proto3" json:"max_number_of_annotations,omitempty"`
+ // The global default max number of message events per span.
+ MaxNumberOfMessageEvents int64 `protobuf:"varint,6,opt,name=max_number_of_message_events,json=maxNumberOfMessageEvents,proto3" json:"max_number_of_message_events,omitempty"`
+ // The global default max number of link entries per span.
+ MaxNumberOfLinks int64 `protobuf:"varint,7,opt,name=max_number_of_links,json=maxNumberOfLinks,proto3" json:"max_number_of_links,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *TraceConfig) Reset() { *m = TraceConfig{} }
+func (m *TraceConfig) String() string { return proto.CompactTextString(m) }
+func (*TraceConfig) ProtoMessage() {}
+func (*TraceConfig) Descriptor() ([]byte, []int) {
+ return fileDescriptor_5359209b41ff50c5, []int{0}
+}
+
+func (m *TraceConfig) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_TraceConfig.Unmarshal(m, b)
+}
+func (m *TraceConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_TraceConfig.Marshal(b, m, deterministic)
+}
+func (m *TraceConfig) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TraceConfig.Merge(m, src)
+}
+func (m *TraceConfig) XXX_Size() int {
+ return xxx_messageInfo_TraceConfig.Size(m)
+}
+func (m *TraceConfig) XXX_DiscardUnknown() {
+ xxx_messageInfo_TraceConfig.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TraceConfig proto.InternalMessageInfo
+
+type isTraceConfig_Sampler interface {
+ isTraceConfig_Sampler()
+}
+
+type TraceConfig_ProbabilitySampler struct {
+ ProbabilitySampler *ProbabilitySampler `protobuf:"bytes,1,opt,name=probability_sampler,json=probabilitySampler,proto3,oneof"`
+}
+
+type TraceConfig_ConstantSampler struct {
+ ConstantSampler *ConstantSampler `protobuf:"bytes,2,opt,name=constant_sampler,json=constantSampler,proto3,oneof"`
+}
+
+type TraceConfig_RateLimitingSampler struct {
+ RateLimitingSampler *RateLimitingSampler `protobuf:"bytes,3,opt,name=rate_limiting_sampler,json=rateLimitingSampler,proto3,oneof"`
+}
+
+func (*TraceConfig_ProbabilitySampler) isTraceConfig_Sampler() {}
+
+func (*TraceConfig_ConstantSampler) isTraceConfig_Sampler() {}
+
+func (*TraceConfig_RateLimitingSampler) isTraceConfig_Sampler() {}
+
+func (m *TraceConfig) GetSampler() isTraceConfig_Sampler {
+ if m != nil {
+ return m.Sampler
+ }
+ return nil
+}
+
+func (m *TraceConfig) GetProbabilitySampler() *ProbabilitySampler {
+ if x, ok := m.GetSampler().(*TraceConfig_ProbabilitySampler); ok {
+ return x.ProbabilitySampler
+ }
+ return nil
+}
+
+func (m *TraceConfig) GetConstantSampler() *ConstantSampler {
+ if x, ok := m.GetSampler().(*TraceConfig_ConstantSampler); ok {
+ return x.ConstantSampler
+ }
+ return nil
+}
+
+func (m *TraceConfig) GetRateLimitingSampler() *RateLimitingSampler {
+ if x, ok := m.GetSampler().(*TraceConfig_RateLimitingSampler); ok {
+ return x.RateLimitingSampler
+ }
+ return nil
+}
+
+func (m *TraceConfig) GetMaxNumberOfAttributes() int64 {
+ if m != nil {
+ return m.MaxNumberOfAttributes
+ }
+ return 0
+}
+
+func (m *TraceConfig) GetMaxNumberOfAnnotations() int64 {
+ if m != nil {
+ return m.MaxNumberOfAnnotations
+ }
+ return 0
+}
+
+func (m *TraceConfig) GetMaxNumberOfMessageEvents() int64 {
+ if m != nil {
+ return m.MaxNumberOfMessageEvents
+ }
+ return 0
+}
+
+func (m *TraceConfig) GetMaxNumberOfLinks() int64 {
+ if m != nil {
+ return m.MaxNumberOfLinks
+ }
+ return 0
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*TraceConfig) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _TraceConfig_OneofMarshaler, _TraceConfig_OneofUnmarshaler, _TraceConfig_OneofSizer, []interface{}{
+ (*TraceConfig_ProbabilitySampler)(nil),
+ (*TraceConfig_ConstantSampler)(nil),
+ (*TraceConfig_RateLimitingSampler)(nil),
+ }
+}
+
+func _TraceConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*TraceConfig)
+ // sampler
+ switch x := m.Sampler.(type) {
+ case *TraceConfig_ProbabilitySampler:
+ b.EncodeVarint(1<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.ProbabilitySampler); err != nil {
+ return err
+ }
+ case *TraceConfig_ConstantSampler:
+ b.EncodeVarint(2<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.ConstantSampler); err != nil {
+ return err
+ }
+ case *TraceConfig_RateLimitingSampler:
+ b.EncodeVarint(3<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.RateLimitingSampler); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("TraceConfig.Sampler has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _TraceConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*TraceConfig)
+ switch tag {
+ case 1: // sampler.probability_sampler
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(ProbabilitySampler)
+ err := b.DecodeMessage(msg)
+ m.Sampler = &TraceConfig_ProbabilitySampler{msg}
+ return true, err
+ case 2: // sampler.constant_sampler
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(ConstantSampler)
+ err := b.DecodeMessage(msg)
+ m.Sampler = &TraceConfig_ConstantSampler{msg}
+ return true, err
+ case 3: // sampler.rate_limiting_sampler
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(RateLimitingSampler)
+ err := b.DecodeMessage(msg)
+ m.Sampler = &TraceConfig_RateLimitingSampler{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _TraceConfig_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*TraceConfig)
+ // sampler
+ switch x := m.Sampler.(type) {
+ case *TraceConfig_ProbabilitySampler:
+ s := proto.Size(x.ProbabilitySampler)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *TraceConfig_ConstantSampler:
+ s := proto.Size(x.ConstantSampler)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *TraceConfig_RateLimitingSampler:
+ s := proto.Size(x.RateLimitingSampler)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// Sampler that tries to uniformly sample traces with a given probability.
+// The probability of sampling a trace is equal to that of the specified probability.
+type ProbabilitySampler struct {
+ // The desired probability of sampling. Must be within [0.0, 1.0].
+ SamplingProbability float64 `protobuf:"fixed64,1,opt,name=samplingProbability,proto3" json:"samplingProbability,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ProbabilitySampler) Reset() { *m = ProbabilitySampler{} }
+func (m *ProbabilitySampler) String() string { return proto.CompactTextString(m) }
+func (*ProbabilitySampler) ProtoMessage() {}
+func (*ProbabilitySampler) Descriptor() ([]byte, []int) {
+ return fileDescriptor_5359209b41ff50c5, []int{1}
+}
+
+func (m *ProbabilitySampler) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ProbabilitySampler.Unmarshal(m, b)
+}
+func (m *ProbabilitySampler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ProbabilitySampler.Marshal(b, m, deterministic)
+}
+func (m *ProbabilitySampler) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ProbabilitySampler.Merge(m, src)
+}
+func (m *ProbabilitySampler) XXX_Size() int {
+ return xxx_messageInfo_ProbabilitySampler.Size(m)
+}
+func (m *ProbabilitySampler) XXX_DiscardUnknown() {
+ xxx_messageInfo_ProbabilitySampler.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ProbabilitySampler proto.InternalMessageInfo
+
+func (m *ProbabilitySampler) GetSamplingProbability() float64 {
+ if m != nil {
+ return m.SamplingProbability
+ }
+ return 0
+}
+
+// Sampler that makes a constant decision (either always "yes" or always "no")
+// on span sampling.
+type ConstantSampler struct {
+ // Whether spans should be always sampled, or never sampled.
+ Decision bool `protobuf:"varint,1,opt,name=decision,proto3" json:"decision,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ConstantSampler) Reset() { *m = ConstantSampler{} }
+func (m *ConstantSampler) String() string { return proto.CompactTextString(m) }
+func (*ConstantSampler) ProtoMessage() {}
+func (*ConstantSampler) Descriptor() ([]byte, []int) {
+ return fileDescriptor_5359209b41ff50c5, []int{2}
+}
+
+func (m *ConstantSampler) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ConstantSampler.Unmarshal(m, b)
+}
+func (m *ConstantSampler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ConstantSampler.Marshal(b, m, deterministic)
+}
+func (m *ConstantSampler) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ConstantSampler.Merge(m, src)
+}
+func (m *ConstantSampler) XXX_Size() int {
+ return xxx_messageInfo_ConstantSampler.Size(m)
+}
+func (m *ConstantSampler) XXX_DiscardUnknown() {
+ xxx_messageInfo_ConstantSampler.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ConstantSampler proto.InternalMessageInfo
+
+func (m *ConstantSampler) GetDecision() bool {
+ if m != nil {
+ return m.Decision
+ }
+ return false
+}
+
+// Sampler that tries to sample with a rate per time window.
+type RateLimitingSampler struct {
+ // Rate per second.
+ Qps int64 `protobuf:"varint,1,opt,name=qps,proto3" json:"qps,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *RateLimitingSampler) Reset() { *m = RateLimitingSampler{} }
+func (m *RateLimitingSampler) String() string { return proto.CompactTextString(m) }
+func (*RateLimitingSampler) ProtoMessage() {}
+func (*RateLimitingSampler) Descriptor() ([]byte, []int) {
+ return fileDescriptor_5359209b41ff50c5, []int{3}
+}
+
+func (m *RateLimitingSampler) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_RateLimitingSampler.Unmarshal(m, b)
+}
+func (m *RateLimitingSampler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_RateLimitingSampler.Marshal(b, m, deterministic)
+}
+func (m *RateLimitingSampler) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_RateLimitingSampler.Merge(m, src)
+}
+func (m *RateLimitingSampler) XXX_Size() int {
+ return xxx_messageInfo_RateLimitingSampler.Size(m)
+}
+func (m *RateLimitingSampler) XXX_DiscardUnknown() {
+ xxx_messageInfo_RateLimitingSampler.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RateLimitingSampler proto.InternalMessageInfo
+
+func (m *RateLimitingSampler) GetQps() int64 {
+ if m != nil {
+ return m.Qps
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterType((*TraceConfig)(nil), "opencensus.proto.trace.v1.TraceConfig")
+ proto.RegisterType((*ProbabilitySampler)(nil), "opencensus.proto.trace.v1.ProbabilitySampler")
+ proto.RegisterType((*ConstantSampler)(nil), "opencensus.proto.trace.v1.ConstantSampler")
+ proto.RegisterType((*RateLimitingSampler)(nil), "opencensus.proto.trace.v1.RateLimitingSampler")
+}
+
+func init() {
+ proto.RegisterFile("opencensus/proto/trace/v1/trace_config.proto", fileDescriptor_5359209b41ff50c5)
+}
+
+var fileDescriptor_5359209b41ff50c5 = []byte{
+ // 431 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x41, 0x6f, 0xd4, 0x30,
+ 0x10, 0x85, 0x09, 0x5b, 0xda, 0x32, 0x3d, 0x74, 0xe5, 0xa8, 0x28, 0x45, 0x3d, 0x54, 0x7b, 0xa1,
+ 0x42, 0x24, 0xa1, 0x70, 0x40, 0x5c, 0x90, 0xd8, 0x0a, 0xc4, 0xa1, 0xc0, 0x2a, 0x20, 0x21, 0x71,
+ 0x09, 0x4e, 0xea, 0x0d, 0x16, 0xf1, 0x38, 0xd8, 0x93, 0xa8, 0xfc, 0x17, 0x7e, 0x6c, 0x15, 0x67,
+ 0x95, 0x64, 0xbb, 0xed, 0xde, 0xec, 0xf7, 0xde, 0xf7, 0x2c, 0x79, 0x6c, 0x78, 0xa1, 0x2b, 0x81,
+ 0xb9, 0x40, 0x5b, 0xdb, 0xb8, 0x32, 0x9a, 0x74, 0x4c, 0x86, 0xe7, 0x22, 0x6e, 0xce, 0xbb, 0x45,
+ 0x9a, 0x6b, 0x5c, 0xca, 0x22, 0x72, 0x1e, 0x3b, 0x1e, 0xd2, 0x9d, 0x12, 0xb9, 0x50, 0xd4, 0x9c,
+ 0xcf, 0xfe, 0xef, 0xc0, 0xc1, 0xf7, 0x76, 0x73, 0xe1, 0x00, 0xf6, 0x0b, 0xfc, 0xca, 0xe8, 0x8c,
+ 0x67, 0xb2, 0x94, 0xf4, 0x2f, 0xb5, 0x5c, 0x55, 0xa5, 0x30, 0x81, 0x77, 0xea, 0x9d, 0x1d, 0xbc,
+ 0x0a, 0xa3, 0x7b, 0x8b, 0xa2, 0xc5, 0x40, 0x7d, 0xeb, 0xa0, 0x4f, 0x0f, 0x12, 0x56, 0x6d, 0xa8,
+ 0xec, 0x07, 0x4c, 0x73, 0x8d, 0x96, 0x38, 0x52, 0x5f, 0xff, 0xd0, 0xd5, 0x3f, 0xdf, 0x52, 0x7f,
+ 0xb1, 0x42, 0x86, 0xee, 0xc3, 0x7c, 0x5d, 0x62, 0x57, 0x70, 0x64, 0x38, 0x89, 0xb4, 0x94, 0x4a,
+ 0x92, 0xc4, 0xa2, 0x6f, 0x9f, 0xb8, 0xf6, 0x68, 0x4b, 0x7b, 0xc2, 0x49, 0x5c, 0xae, 0xb0, 0xe1,
+ 0x04, 0xdf, 0x6c, 0xca, 0xec, 0x0d, 0x04, 0x8a, 0x5f, 0xa7, 0x58, 0xab, 0x4c, 0x98, 0x54, 0x2f,
+ 0x53, 0x4e, 0x64, 0x64, 0x56, 0x93, 0xb0, 0xc1, 0xce, 0xa9, 0x77, 0x36, 0x49, 0x8e, 0x14, 0xbf,
+ 0xfe, 0xe2, 0xec, 0xaf, 0xcb, 0xf7, 0xbd, 0xc9, 0xde, 0xc2, 0xf1, 0x2d, 0x10, 0x51, 0x13, 0x27,
+ 0xa9, 0xd1, 0x06, 0x8f, 0x1c, 0xf9, 0x64, 0x4c, 0x0e, 0x2e, 0x7b, 0x07, 0x27, 0xeb, 0xa8, 0x12,
+ 0xd6, 0xf2, 0x42, 0xa4, 0xa2, 0x11, 0x48, 0x36, 0xd8, 0x75, 0x74, 0x30, 0xa2, 0x3f, 0x77, 0x81,
+ 0x0f, 0xce, 0x67, 0x21, 0xf8, 0xeb, 0x7c, 0x29, 0xf1, 0x8f, 0x0d, 0xf6, 0x1c, 0x36, 0x1d, 0x61,
+ 0x97, 0xad, 0x3e, 0x7f, 0x0c, 0x7b, 0xab, 0xab, 0x9b, 0x7d, 0x04, 0xb6, 0x39, 0x58, 0xf6, 0x12,
+ 0x7c, 0x17, 0x90, 0x58, 0x8c, 0x5c, 0xf7, 0x48, 0xbc, 0xe4, 0x2e, 0x6b, 0x16, 0xc2, 0xe1, 0xad,
+ 0x09, 0xb2, 0xa7, 0xb0, 0x7f, 0x25, 0x72, 0x69, 0xa5, 0x46, 0x47, 0xee, 0x27, 0xfd, 0x7e, 0xf6,
+ 0x0c, 0xfc, 0x3b, 0x46, 0xc2, 0xa6, 0x30, 0xf9, 0x5b, 0x59, 0x97, 0x9e, 0x24, 0xed, 0x72, 0xde,
+ 0xc0, 0x89, 0xd4, 0xf7, 0x0f, 0x76, 0x3e, 0x1d, 0xbd, 0xed, 0x45, 0x6b, 0x2d, 0xbc, 0x9f, 0xf3,
+ 0x42, 0xd2, 0xef, 0x3a, 0x8b, 0x72, 0xad, 0xe2, 0x8e, 0x0a, 0x25, 0x5a, 0x32, 0xb5, 0x12, 0xd8,
+ 0xdd, 0x78, 0x3c, 0x14, 0x86, 0xdd, 0xef, 0x2a, 0x04, 0x86, 0xc5, 0xf0, 0xc9, 0xb2, 0x5d, 0x27,
+ 0xbf, 0xbe, 0x09, 0x00, 0x00, 0xff, 0xff, 0x1e, 0x98, 0xa1, 0x9e, 0x88, 0x03, 0x00, 0x00,
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/.gitignore b/vendor/github.com/dgrijalva/jwt-go/.gitignore
new file mode 100644
index 0000000000..80bed650ec
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/.gitignore
@@ -0,0 +1,4 @@
+.DS_Store
+bin
+
+
diff --git a/vendor/github.com/dgrijalva/jwt-go/.travis.yml b/vendor/github.com/dgrijalva/jwt-go/.travis.yml
new file mode 100644
index 0000000000..1027f56cd9
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/.travis.yml
@@ -0,0 +1,13 @@
+language: go
+
+script:
+ - go vet ./...
+ - go test -v ./...
+
+go:
+ - 1.3
+ - 1.4
+ - 1.5
+ - 1.6
+ - 1.7
+ - tip
diff --git a/vendor/github.com/dgrijalva/jwt-go/LICENSE b/vendor/github.com/dgrijalva/jwt-go/LICENSE
new file mode 100644
index 0000000000..df83a9c2f0
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/LICENSE
@@ -0,0 +1,8 @@
+Copyright (c) 2012 Dave Grijalva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md b/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md
new file mode 100644
index 0000000000..7fc1f793cb
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md
@@ -0,0 +1,97 @@
+## Migration Guide from v2 -> v3
+
+Version 3 adds several new, frequently requested features. To do so, it introduces a few breaking changes. We've worked to keep these as minimal as possible. This guide explains the breaking changes and how you can quickly update your code.
+
+### `Token.Claims` is now an interface type
+
+The most requested feature from the 2.0 verison of this library was the ability to provide a custom type to the JSON parser for claims. This was implemented by introducing a new interface, `Claims`, to replace `map[string]interface{}`. We also included two concrete implementations of `Claims`: `MapClaims` and `StandardClaims`.
+
+`MapClaims` is an alias for `map[string]interface{}` with built in validation behavior. It is the default claims type when using `Parse`. The usage is unchanged except you must type cast the claims property.
+
+The old example for parsing a token looked like this..
+
+```go
+ if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil {
+ fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"])
+ }
+```
+
+is now directly mapped to...
+
+```go
+ if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil {
+ claims := token.Claims.(jwt.MapClaims)
+ fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"])
+ }
+```
+
+`StandardClaims` is designed to be embedded in your custom type. You can supply a custom claims type with the new `ParseWithClaims` function. Here's an example of using a custom claims type.
+
+```go
+ type MyCustomClaims struct {
+ User string
+ *StandardClaims
+ }
+
+ if token, err := jwt.ParseWithClaims(tokenString, &MyCustomClaims{}, keyLookupFunc); err == nil {
+ claims := token.Claims.(*MyCustomClaims)
+ fmt.Printf("Token for user %v expires %v", claims.User, claims.StandardClaims.ExpiresAt)
+ }
+```
+
+### `ParseFromRequest` has been moved
+
+To keep this library focused on the tokens without becoming overburdened with complex request processing logic, `ParseFromRequest` and its new companion `ParseFromRequestWithClaims` have been moved to a subpackage, `request`. The method signatues have also been augmented to receive a new argument: `Extractor`.
+
+`Extractors` do the work of picking the token string out of a request. The interface is simple and composable.
+
+This simple parsing example:
+
+```go
+ if token, err := jwt.ParseFromRequest(tokenString, req, keyLookupFunc); err == nil {
+ fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"])
+ }
+```
+
+is directly mapped to:
+
+```go
+ if token, err := request.ParseFromRequest(req, request.OAuth2Extractor, keyLookupFunc); err == nil {
+ claims := token.Claims.(jwt.MapClaims)
+ fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"])
+ }
+```
+
+There are several concrete `Extractor` types provided for your convenience:
+
+* `HeaderExtractor` will search a list of headers until one contains content.
+* `ArgumentExtractor` will search a list of keys in request query and form arguments until one contains content.
+* `MultiExtractor` will try a list of `Extractors` in order until one returns content.
+* `AuthorizationHeaderExtractor` will look in the `Authorization` header for a `Bearer` token.
+* `OAuth2Extractor` searches the places an OAuth2 token would be specified (per the spec): `Authorization` header and `access_token` argument
+* `PostExtractionFilter` wraps an `Extractor`, allowing you to process the content before it's parsed. A simple example is stripping the `Bearer ` text from a header
+
+
+### RSA signing methods no longer accept `[]byte` keys
+
+Due to a [critical vulnerability](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/), we've decided the convenience of accepting `[]byte` instead of `rsa.PublicKey` or `rsa.PrivateKey` isn't worth the risk of misuse.
+
+To replace this behavior, we've added two helper methods: `ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error)` and `ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error)`. These are just simple helpers for unpacking PEM encoded PKCS1 and PKCS8 keys. If your keys are encoded any other way, all you need to do is convert them to the `crypto/rsa` package's types.
+
+```go
+ func keyLookupFunc(*Token) (interface{}, error) {
+ // Don't forget to validate the alg is what you expect:
+ if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
+ return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
+ }
+
+ // Look up key
+ key, err := lookupPublicKey(token.Header["kid"])
+ if err != nil {
+ return nil, err
+ }
+
+ // Unpack key from PEM encoded PKCS8
+ return jwt.ParseRSAPublicKeyFromPEM(key)
+ }
+```
diff --git a/vendor/github.com/dgrijalva/jwt-go/README.md b/vendor/github.com/dgrijalva/jwt-go/README.md
new file mode 100644
index 0000000000..d358d881b8
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/README.md
@@ -0,0 +1,100 @@
+# jwt-go
+
+[](https://travis-ci.org/dgrijalva/jwt-go)
+[](https://godoc.org/github.com/dgrijalva/jwt-go)
+
+A [go](http://www.golang.org) (or 'golang' for search engine friendliness) implementation of [JSON Web Tokens](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html)
+
+**NEW VERSION COMING:** There have been a lot of improvements suggested since the version 3.0.0 released in 2016. I'm working now on cutting two different releases: 3.2.0 will contain any non-breaking changes or enhancements. 4.0.0 will follow shortly which will include breaking changes. See the 4.0.0 milestone to get an idea of what's coming. If you have other ideas, or would like to participate in 4.0.0, now's the time. If you depend on this library and don't want to be interrupted, I recommend you use your dependency mangement tool to pin to version 3.
+
+**SECURITY NOTICE:** Some older versions of Go have a security issue in the cryotp/elliptic. Recommendation is to upgrade to at least 1.8.3. See issue #216 for more detail.
+
+**SECURITY NOTICE:** It's important that you [validate the `alg` presented is what you expect](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/). This library attempts to make it easy to do the right thing by requiring key types match the expected alg, but you should take the extra step to verify it in your usage. See the examples provided.
+
+## What the heck is a JWT?
+
+JWT.io has [a great introduction](https://jwt.io/introduction) to JSON Web Tokens.
+
+In short, it's a signed JSON object that does something useful (for example, authentication). It's commonly used for `Bearer` tokens in Oauth 2. A token is made of three parts, separated by `.`'s. The first two parts are JSON objects, that have been [base64url](http://tools.ietf.org/html/rfc4648) encoded. The last part is the signature, encoded the same way.
+
+The first part is called the header. It contains the necessary information for verifying the last part, the signature. For example, which encryption method was used for signing and what key was used.
+
+The part in the middle is the interesting bit. It's called the Claims and contains the actual stuff you care about. Refer to [the RFC](http://self-issued.info/docs/draft-jones-json-web-token.html) for information about reserved keys and the proper way to add your own.
+
+## What's in the box?
+
+This library supports the parsing and verification as well as the generation and signing of JWTs. Current supported signing algorithms are HMAC SHA, RSA, RSA-PSS, and ECDSA, though hooks are present for adding your own.
+
+## Examples
+
+See [the project documentation](https://godoc.org/github.com/dgrijalva/jwt-go) for examples of usage:
+
+* [Simple example of parsing and validating a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-Parse--Hmac)
+* [Simple example of building and signing a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-New--Hmac)
+* [Directory of Examples](https://godoc.org/github.com/dgrijalva/jwt-go#pkg-examples)
+
+## Extensions
+
+This library publishes all the necessary components for adding your own signing methods. Simply implement the `SigningMethod` interface and register a factory method using `RegisterSigningMethod`.
+
+Here's an example of an extension that integrates with the Google App Engine signing tools: https://github.com/someone1/gcp-jwt-go
+
+## Compliance
+
+This library was last reviewed to comply with [RTF 7519](http://www.rfc-editor.org/info/rfc7519) dated May 2015 with a few notable differences:
+
+* In order to protect against accidental use of [Unsecured JWTs](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html#UnsecuredJWT), tokens using `alg=none` will only be accepted if the constant `jwt.UnsafeAllowNoneSignatureType` is provided as the key.
+
+## Project Status & Versioning
+
+This library is considered production ready. Feedback and feature requests are appreciated. The API should be considered stable. There should be very few backwards-incompatible changes outside of major version updates (and only with good reason).
+
+This project uses [Semantic Versioning 2.0.0](http://semver.org). Accepted pull requests will land on `master`. Periodically, versions will be tagged from `master`. You can find all the releases on [the project releases page](https://github.com/dgrijalva/jwt-go/releases).
+
+While we try to make it obvious when we make breaking changes, there isn't a great mechanism for pushing announcements out to users. You may want to use this alternative package include: `gopkg.in/dgrijalva/jwt-go.v3`. It will do the right thing WRT semantic versioning.
+
+**BREAKING CHANGES:***
+* Version 3.0.0 includes _a lot_ of changes from the 2.x line, including a few that break the API. We've tried to break as few things as possible, so there should just be a few type signature changes. A full list of breaking changes is available in `VERSION_HISTORY.md`. See `MIGRATION_GUIDE.md` for more information on updating your code.
+
+## Usage Tips
+
+### Signing vs Encryption
+
+A token is simply a JSON object that is signed by its author. this tells you exactly two things about the data:
+
+* The author of the token was in the possession of the signing secret
+* The data has not been modified since it was signed
+
+It's important to know that JWT does not provide encryption, which means anyone who has access to the token can read its contents. If you need to protect (encrypt) the data, there is a companion spec, `JWE`, that provides this functionality. JWE is currently outside the scope of this library.
+
+### Choosing a Signing Method
+
+There are several signing methods available, and you should probably take the time to learn about the various options before choosing one. The principal design decision is most likely going to be symmetric vs asymmetric.
+
+Symmetric signing methods, such as HSA, use only a single secret. This is probably the simplest signing method to use since any `[]byte` can be used as a valid secret. They are also slightly computationally faster to use, though this rarely is enough to matter. Symmetric signing methods work the best when both producers and consumers of tokens are trusted, or even the same system. Since the same secret is used to both sign and validate tokens, you can't easily distribute the key for validation.
+
+Asymmetric signing methods, such as RSA, use different keys for signing and verifying tokens. This makes it possible to produce tokens with a private key, and allow any consumer to access the public key for verification.
+
+### Signing Methods and Key Types
+
+Each signing method expects a different object type for its signing keys. See the package documentation for details. Here are the most common ones:
+
+* The [HMAC signing method](https://godoc.org/github.com/dgrijalva/jwt-go#SigningMethodHMAC) (`HS256`,`HS384`,`HS512`) expect `[]byte` values for signing and validation
+* The [RSA signing method](https://godoc.org/github.com/dgrijalva/jwt-go#SigningMethodRSA) (`RS256`,`RS384`,`RS512`) expect `*rsa.PrivateKey` for signing and `*rsa.PublicKey` for validation
+* The [ECDSA signing method](https://godoc.org/github.com/dgrijalva/jwt-go#SigningMethodECDSA) (`ES256`,`ES384`,`ES512`) expect `*ecdsa.PrivateKey` for signing and `*ecdsa.PublicKey` for validation
+
+### JWT and OAuth
+
+It's worth mentioning that OAuth and JWT are not the same thing. A JWT token is simply a signed JSON object. It can be used anywhere such a thing is useful. There is some confusion, though, as JWT is the most common type of bearer token used in OAuth2 authentication.
+
+Without going too far down the rabbit hole, here's a description of the interaction of these technologies:
+
+* OAuth is a protocol for allowing an identity provider to be separate from the service a user is logging in to. For example, whenever you use Facebook to log into a different service (Yelp, Spotify, etc), you are using OAuth.
+* OAuth defines several options for passing around authentication data. One popular method is called a "bearer token". A bearer token is simply a string that _should_ only be held by an authenticated user. Thus, simply presenting this token proves your identity. You can probably derive from here why a JWT might make a good bearer token.
+* Because bearer tokens are used for authentication, it's important they're kept secret. This is why transactions that use bearer tokens typically happen over SSL.
+
+## More
+
+Documentation can be found [on godoc.org](http://godoc.org/github.com/dgrijalva/jwt-go).
+
+The command line utility included in this project (cmd/jwt) provides a straightforward example of token creation and parsing as well as a useful tool for debugging your own integration. You'll also find several implementation examples in the documentation.
diff --git a/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md b/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md
new file mode 100644
index 0000000000..6370298313
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md
@@ -0,0 +1,118 @@
+## `jwt-go` Version History
+
+#### 3.2.0
+
+* Added method `ParseUnverified` to allow users to split up the tasks of parsing and validation
+* HMAC signing method returns `ErrInvalidKeyType` instead of `ErrInvalidKey` where appropriate
+* Added options to `request.ParseFromRequest`, which allows for an arbitrary list of modifiers to parsing behavior. Initial set include `WithClaims` and `WithParser`. Existing usage of this function will continue to work as before.
+* Deprecated `ParseFromRequestWithClaims` to simplify API in the future.
+
+#### 3.1.0
+
+* Improvements to `jwt` command line tool
+* Added `SkipClaimsValidation` option to `Parser`
+* Documentation updates
+
+#### 3.0.0
+
+* **Compatibility Breaking Changes**: See MIGRATION_GUIDE.md for tips on updating your code
+ * Dropped support for `[]byte` keys when using RSA signing methods. This convenience feature could contribute to security vulnerabilities involving mismatched key types with signing methods.
+ * `ParseFromRequest` has been moved to `request` subpackage and usage has changed
+ * The `Claims` property on `Token` is now type `Claims` instead of `map[string]interface{}`. The default value is type `MapClaims`, which is an alias to `map[string]interface{}`. This makes it possible to use a custom type when decoding claims.
+* Other Additions and Changes
+ * Added `Claims` interface type to allow users to decode the claims into a custom type
+ * Added `ParseWithClaims`, which takes a third argument of type `Claims`. Use this function instead of `Parse` if you have a custom type you'd like to decode into.
+ * Dramatically improved the functionality and flexibility of `ParseFromRequest`, which is now in the `request` subpackage
+ * Added `ParseFromRequestWithClaims` which is the `FromRequest` equivalent of `ParseWithClaims`
+ * Added new interface type `Extractor`, which is used for extracting JWT strings from http requests. Used with `ParseFromRequest` and `ParseFromRequestWithClaims`.
+ * Added several new, more specific, validation errors to error type bitmask
+ * Moved examples from README to executable example files
+ * Signing method registry is now thread safe
+ * Added new property to `ValidationError`, which contains the raw error returned by calls made by parse/verify (such as those returned by keyfunc or json parser)
+
+#### 2.7.0
+
+This will likely be the last backwards compatible release before 3.0.0, excluding essential bug fixes.
+
+* Added new option `-show` to the `jwt` command that will just output the decoded token without verifying
+* Error text for expired tokens includes how long it's been expired
+* Fixed incorrect error returned from `ParseRSAPublicKeyFromPEM`
+* Documentation updates
+
+#### 2.6.0
+
+* Exposed inner error within ValidationError
+* Fixed validation errors when using UseJSONNumber flag
+* Added several unit tests
+
+#### 2.5.0
+
+* Added support for signing method none. You shouldn't use this. The API tries to make this clear.
+* Updated/fixed some documentation
+* Added more helpful error message when trying to parse tokens that begin with `BEARER `
+
+#### 2.4.0
+
+* Added new type, Parser, to allow for configuration of various parsing parameters
+ * You can now specify a list of valid signing methods. Anything outside this set will be rejected.
+ * You can now opt to use the `json.Number` type instead of `float64` when parsing token JSON
+* Added support for [Travis CI](https://travis-ci.org/dgrijalva/jwt-go)
+* Fixed some bugs with ECDSA parsing
+
+#### 2.3.0
+
+* Added support for ECDSA signing methods
+* Added support for RSA PSS signing methods (requires go v1.4)
+
+#### 2.2.0
+
+* Gracefully handle a `nil` `Keyfunc` being passed to `Parse`. Result will now be the parsed token and an error, instead of a panic.
+
+#### 2.1.0
+
+Backwards compatible API change that was missed in 2.0.0.
+
+* The `SignedString` method on `Token` now takes `interface{}` instead of `[]byte`
+
+#### 2.0.0
+
+There were two major reasons for breaking backwards compatibility with this update. The first was a refactor required to expand the width of the RSA and HMAC-SHA signing implementations. There will likely be no required code changes to support this change.
+
+The second update, while unfortunately requiring a small change in integration, is required to open up this library to other signing methods. Not all keys used for all signing methods have a single standard on-disk representation. Requiring `[]byte` as the type for all keys proved too limiting. Additionally, this implementation allows for pre-parsed tokens to be reused, which might matter in an application that parses a high volume of tokens with a small set of keys. Backwards compatibilty has been maintained for passing `[]byte` to the RSA signing methods, but they will also accept `*rsa.PublicKey` and `*rsa.PrivateKey`.
+
+It is likely the only integration change required here will be to change `func(t *jwt.Token) ([]byte, error)` to `func(t *jwt.Token) (interface{}, error)` when calling `Parse`.
+
+* **Compatibility Breaking Changes**
+ * `SigningMethodHS256` is now `*SigningMethodHMAC` instead of `type struct`
+ * `SigningMethodRS256` is now `*SigningMethodRSA` instead of `type struct`
+ * `KeyFunc` now returns `interface{}` instead of `[]byte`
+ * `SigningMethod.Sign` now takes `interface{}` instead of `[]byte` for the key
+ * `SigningMethod.Verify` now takes `interface{}` instead of `[]byte` for the key
+* Renamed type `SigningMethodHS256` to `SigningMethodHMAC`. Specific sizes are now just instances of this type.
+ * Added public package global `SigningMethodHS256`
+ * Added public package global `SigningMethodHS384`
+ * Added public package global `SigningMethodHS512`
+* Renamed type `SigningMethodRS256` to `SigningMethodRSA`. Specific sizes are now just instances of this type.
+ * Added public package global `SigningMethodRS256`
+ * Added public package global `SigningMethodRS384`
+ * Added public package global `SigningMethodRS512`
+* Moved sample private key for HMAC tests from an inline value to a file on disk. Value is unchanged.
+* Refactored the RSA implementation to be easier to read
+* Exposed helper methods `ParseRSAPrivateKeyFromPEM` and `ParseRSAPublicKeyFromPEM`
+
+#### 1.0.2
+
+* Fixed bug in parsing public keys from certificates
+* Added more tests around the parsing of keys for RS256
+* Code refactoring in RS256 implementation. No functional changes
+
+#### 1.0.1
+
+* Fixed panic if RS256 signing method was passed an invalid key
+
+#### 1.0.0
+
+* First versioned release
+* API stabilized
+* Supports creating, signing, parsing, and validating JWT tokens
+* Supports RS256 and HS256 signing methods
\ No newline at end of file
diff --git a/vendor/github.com/dgrijalva/jwt-go/claims.go b/vendor/github.com/dgrijalva/jwt-go/claims.go
new file mode 100644
index 0000000000..f0228f02e0
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/claims.go
@@ -0,0 +1,134 @@
+package jwt
+
+import (
+ "crypto/subtle"
+ "fmt"
+ "time"
+)
+
+// For a type to be a Claims object, it must just have a Valid method that determines
+// if the token is invalid for any supported reason
+type Claims interface {
+ Valid() error
+}
+
+// Structured version of Claims Section, as referenced at
+// https://tools.ietf.org/html/rfc7519#section-4.1
+// See examples for how to use this with your own claim types
+type StandardClaims struct {
+ Audience string `json:"aud,omitempty"`
+ ExpiresAt int64 `json:"exp,omitempty"`
+ Id string `json:"jti,omitempty"`
+ IssuedAt int64 `json:"iat,omitempty"`
+ Issuer string `json:"iss,omitempty"`
+ NotBefore int64 `json:"nbf,omitempty"`
+ Subject string `json:"sub,omitempty"`
+}
+
+// Validates time based claims "exp, iat, nbf".
+// There is no accounting for clock skew.
+// As well, if any of the above claims are not in the token, it will still
+// be considered a valid claim.
+func (c StandardClaims) Valid() error {
+ vErr := new(ValidationError)
+ now := TimeFunc().Unix()
+
+ // The claims below are optional, by default, so if they are set to the
+ // default value in Go, let's not fail the verification for them.
+ if c.VerifyExpiresAt(now, false) == false {
+ delta := time.Unix(now, 0).Sub(time.Unix(c.ExpiresAt, 0))
+ vErr.Inner = fmt.Errorf("token is expired by %v", delta)
+ vErr.Errors |= ValidationErrorExpired
+ }
+
+ if c.VerifyIssuedAt(now, false) == false {
+ vErr.Inner = fmt.Errorf("Token used before issued")
+ vErr.Errors |= ValidationErrorIssuedAt
+ }
+
+ if c.VerifyNotBefore(now, false) == false {
+ vErr.Inner = fmt.Errorf("token is not valid yet")
+ vErr.Errors |= ValidationErrorNotValidYet
+ }
+
+ if vErr.valid() {
+ return nil
+ }
+
+ return vErr
+}
+
+// Compares the aud claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyAudience(cmp string, req bool) bool {
+ return verifyAud(c.Audience, cmp, req)
+}
+
+// Compares the exp claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyExpiresAt(cmp int64, req bool) bool {
+ return verifyExp(c.ExpiresAt, cmp, req)
+}
+
+// Compares the iat claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyIssuedAt(cmp int64, req bool) bool {
+ return verifyIat(c.IssuedAt, cmp, req)
+}
+
+// Compares the iss claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyIssuer(cmp string, req bool) bool {
+ return verifyIss(c.Issuer, cmp, req)
+}
+
+// Compares the nbf claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyNotBefore(cmp int64, req bool) bool {
+ return verifyNbf(c.NotBefore, cmp, req)
+}
+
+// ----- helpers
+
+func verifyAud(aud string, cmp string, required bool) bool {
+ if aud == "" {
+ return !required
+ }
+ if subtle.ConstantTimeCompare([]byte(aud), []byte(cmp)) != 0 {
+ return true
+ } else {
+ return false
+ }
+}
+
+func verifyExp(exp int64, now int64, required bool) bool {
+ if exp == 0 {
+ return !required
+ }
+ return now <= exp
+}
+
+func verifyIat(iat int64, now int64, required bool) bool {
+ if iat == 0 {
+ return !required
+ }
+ return now >= iat
+}
+
+func verifyIss(iss string, cmp string, required bool) bool {
+ if iss == "" {
+ return !required
+ }
+ if subtle.ConstantTimeCompare([]byte(iss), []byte(cmp)) != 0 {
+ return true
+ } else {
+ return false
+ }
+}
+
+func verifyNbf(nbf int64, now int64, required bool) bool {
+ if nbf == 0 {
+ return !required
+ }
+ return now >= nbf
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/doc.go b/vendor/github.com/dgrijalva/jwt-go/doc.go
new file mode 100644
index 0000000000..a86dc1a3b3
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/doc.go
@@ -0,0 +1,4 @@
+// Package jwt is a Go implementation of JSON Web Tokens: http://self-issued.info/docs/draft-jones-json-web-token.html
+//
+// See README.md for more info.
+package jwt
diff --git a/vendor/github.com/dgrijalva/jwt-go/ecdsa.go b/vendor/github.com/dgrijalva/jwt-go/ecdsa.go
new file mode 100644
index 0000000000..f977381240
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/ecdsa.go
@@ -0,0 +1,148 @@
+package jwt
+
+import (
+ "crypto"
+ "crypto/ecdsa"
+ "crypto/rand"
+ "errors"
+ "math/big"
+)
+
+var (
+ // Sadly this is missing from crypto/ecdsa compared to crypto/rsa
+ ErrECDSAVerification = errors.New("crypto/ecdsa: verification error")
+)
+
+// Implements the ECDSA family of signing methods signing methods
+// Expects *ecdsa.PrivateKey for signing and *ecdsa.PublicKey for verification
+type SigningMethodECDSA struct {
+ Name string
+ Hash crypto.Hash
+ KeySize int
+ CurveBits int
+}
+
+// Specific instances for EC256 and company
+var (
+ SigningMethodES256 *SigningMethodECDSA
+ SigningMethodES384 *SigningMethodECDSA
+ SigningMethodES512 *SigningMethodECDSA
+)
+
+func init() {
+ // ES256
+ SigningMethodES256 = &SigningMethodECDSA{"ES256", crypto.SHA256, 32, 256}
+ RegisterSigningMethod(SigningMethodES256.Alg(), func() SigningMethod {
+ return SigningMethodES256
+ })
+
+ // ES384
+ SigningMethodES384 = &SigningMethodECDSA{"ES384", crypto.SHA384, 48, 384}
+ RegisterSigningMethod(SigningMethodES384.Alg(), func() SigningMethod {
+ return SigningMethodES384
+ })
+
+ // ES512
+ SigningMethodES512 = &SigningMethodECDSA{"ES512", crypto.SHA512, 66, 521}
+ RegisterSigningMethod(SigningMethodES512.Alg(), func() SigningMethod {
+ return SigningMethodES512
+ })
+}
+
+func (m *SigningMethodECDSA) Alg() string {
+ return m.Name
+}
+
+// Implements the Verify method from SigningMethod
+// For this verify method, key must be an ecdsa.PublicKey struct
+func (m *SigningMethodECDSA) Verify(signingString, signature string, key interface{}) error {
+ var err error
+
+ // Decode the signature
+ var sig []byte
+ if sig, err = DecodeSegment(signature); err != nil {
+ return err
+ }
+
+ // Get the key
+ var ecdsaKey *ecdsa.PublicKey
+ switch k := key.(type) {
+ case *ecdsa.PublicKey:
+ ecdsaKey = k
+ default:
+ return ErrInvalidKeyType
+ }
+
+ if len(sig) != 2*m.KeySize {
+ return ErrECDSAVerification
+ }
+
+ r := big.NewInt(0).SetBytes(sig[:m.KeySize])
+ s := big.NewInt(0).SetBytes(sig[m.KeySize:])
+
+ // Create hasher
+ if !m.Hash.Available() {
+ return ErrHashUnavailable
+ }
+ hasher := m.Hash.New()
+ hasher.Write([]byte(signingString))
+
+ // Verify the signature
+ if verifystatus := ecdsa.Verify(ecdsaKey, hasher.Sum(nil), r, s); verifystatus == true {
+ return nil
+ } else {
+ return ErrECDSAVerification
+ }
+}
+
+// Implements the Sign method from SigningMethod
+// For this signing method, key must be an ecdsa.PrivateKey struct
+func (m *SigningMethodECDSA) Sign(signingString string, key interface{}) (string, error) {
+ // Get the key
+ var ecdsaKey *ecdsa.PrivateKey
+ switch k := key.(type) {
+ case *ecdsa.PrivateKey:
+ ecdsaKey = k
+ default:
+ return "", ErrInvalidKeyType
+ }
+
+ // Create the hasher
+ if !m.Hash.Available() {
+ return "", ErrHashUnavailable
+ }
+
+ hasher := m.Hash.New()
+ hasher.Write([]byte(signingString))
+
+ // Sign the string and return r, s
+ if r, s, err := ecdsa.Sign(rand.Reader, ecdsaKey, hasher.Sum(nil)); err == nil {
+ curveBits := ecdsaKey.Curve.Params().BitSize
+
+ if m.CurveBits != curveBits {
+ return "", ErrInvalidKey
+ }
+
+ keyBytes := curveBits / 8
+ if curveBits%8 > 0 {
+ keyBytes += 1
+ }
+
+ // We serialize the outpus (r and s) into big-endian byte arrays and pad
+ // them with zeros on the left to make sure the sizes work out. Both arrays
+ // must be keyBytes long, and the output must be 2*keyBytes long.
+ rBytes := r.Bytes()
+ rBytesPadded := make([]byte, keyBytes)
+ copy(rBytesPadded[keyBytes-len(rBytes):], rBytes)
+
+ sBytes := s.Bytes()
+ sBytesPadded := make([]byte, keyBytes)
+ copy(sBytesPadded[keyBytes-len(sBytes):], sBytes)
+
+ out := append(rBytesPadded, sBytesPadded...)
+
+ return EncodeSegment(out), nil
+ } else {
+ return "", err
+ }
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/ecdsa_utils.go b/vendor/github.com/dgrijalva/jwt-go/ecdsa_utils.go
new file mode 100644
index 0000000000..d19624b726
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/ecdsa_utils.go
@@ -0,0 +1,67 @@
+package jwt
+
+import (
+ "crypto/ecdsa"
+ "crypto/x509"
+ "encoding/pem"
+ "errors"
+)
+
+var (
+ ErrNotECPublicKey = errors.New("Key is not a valid ECDSA public key")
+ ErrNotECPrivateKey = errors.New("Key is not a valid ECDSA private key")
+)
+
+// Parse PEM encoded Elliptic Curve Private Key Structure
+func ParseECPrivateKeyFromPEM(key []byte) (*ecdsa.PrivateKey, error) {
+ var err error
+
+ // Parse PEM block
+ var block *pem.Block
+ if block, _ = pem.Decode(key); block == nil {
+ return nil, ErrKeyMustBePEMEncoded
+ }
+
+ // Parse the key
+ var parsedKey interface{}
+ if parsedKey, err = x509.ParseECPrivateKey(block.Bytes); err != nil {
+ return nil, err
+ }
+
+ var pkey *ecdsa.PrivateKey
+ var ok bool
+ if pkey, ok = parsedKey.(*ecdsa.PrivateKey); !ok {
+ return nil, ErrNotECPrivateKey
+ }
+
+ return pkey, nil
+}
+
+// Parse PEM encoded PKCS1 or PKCS8 public key
+func ParseECPublicKeyFromPEM(key []byte) (*ecdsa.PublicKey, error) {
+ var err error
+
+ // Parse PEM block
+ var block *pem.Block
+ if block, _ = pem.Decode(key); block == nil {
+ return nil, ErrKeyMustBePEMEncoded
+ }
+
+ // Parse the key
+ var parsedKey interface{}
+ if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {
+ if cert, err := x509.ParseCertificate(block.Bytes); err == nil {
+ parsedKey = cert.PublicKey
+ } else {
+ return nil, err
+ }
+ }
+
+ var pkey *ecdsa.PublicKey
+ var ok bool
+ if pkey, ok = parsedKey.(*ecdsa.PublicKey); !ok {
+ return nil, ErrNotECPublicKey
+ }
+
+ return pkey, nil
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/errors.go b/vendor/github.com/dgrijalva/jwt-go/errors.go
new file mode 100644
index 0000000000..1c93024aad
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/errors.go
@@ -0,0 +1,59 @@
+package jwt
+
+import (
+ "errors"
+)
+
+// Error constants
+var (
+ ErrInvalidKey = errors.New("key is invalid")
+ ErrInvalidKeyType = errors.New("key is of invalid type")
+ ErrHashUnavailable = errors.New("the requested hash function is unavailable")
+)
+
+// The errors that might occur when parsing and validating a token
+const (
+ ValidationErrorMalformed uint32 = 1 << iota // Token is malformed
+ ValidationErrorUnverifiable // Token could not be verified because of signing problems
+ ValidationErrorSignatureInvalid // Signature validation failed
+
+ // Standard Claim validation errors
+ ValidationErrorAudience // AUD validation failed
+ ValidationErrorExpired // EXP validation failed
+ ValidationErrorIssuedAt // IAT validation failed
+ ValidationErrorIssuer // ISS validation failed
+ ValidationErrorNotValidYet // NBF validation failed
+ ValidationErrorId // JTI validation failed
+ ValidationErrorClaimsInvalid // Generic claims validation error
+)
+
+// Helper for constructing a ValidationError with a string error message
+func NewValidationError(errorText string, errorFlags uint32) *ValidationError {
+ return &ValidationError{
+ text: errorText,
+ Errors: errorFlags,
+ }
+}
+
+// The error from Parse if token is not valid
+type ValidationError struct {
+ Inner error // stores the error returned by external dependencies, i.e.: KeyFunc
+ Errors uint32 // bitfield. see ValidationError... constants
+ text string // errors that do not have a valid error just have text
+}
+
+// Validation error is an error type
+func (e ValidationError) Error() string {
+ if e.Inner != nil {
+ return e.Inner.Error()
+ } else if e.text != "" {
+ return e.text
+ } else {
+ return "token is invalid"
+ }
+}
+
+// No errors
+func (e *ValidationError) valid() bool {
+ return e.Errors == 0
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/hmac.go b/vendor/github.com/dgrijalva/jwt-go/hmac.go
new file mode 100644
index 0000000000..addbe5d401
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/hmac.go
@@ -0,0 +1,95 @@
+package jwt
+
+import (
+ "crypto"
+ "crypto/hmac"
+ "errors"
+)
+
+// Implements the HMAC-SHA family of signing methods signing methods
+// Expects key type of []byte for both signing and validation
+type SigningMethodHMAC struct {
+ Name string
+ Hash crypto.Hash
+}
+
+// Specific instances for HS256 and company
+var (
+ SigningMethodHS256 *SigningMethodHMAC
+ SigningMethodHS384 *SigningMethodHMAC
+ SigningMethodHS512 *SigningMethodHMAC
+ ErrSignatureInvalid = errors.New("signature is invalid")
+)
+
+func init() {
+ // HS256
+ SigningMethodHS256 = &SigningMethodHMAC{"HS256", crypto.SHA256}
+ RegisterSigningMethod(SigningMethodHS256.Alg(), func() SigningMethod {
+ return SigningMethodHS256
+ })
+
+ // HS384
+ SigningMethodHS384 = &SigningMethodHMAC{"HS384", crypto.SHA384}
+ RegisterSigningMethod(SigningMethodHS384.Alg(), func() SigningMethod {
+ return SigningMethodHS384
+ })
+
+ // HS512
+ SigningMethodHS512 = &SigningMethodHMAC{"HS512", crypto.SHA512}
+ RegisterSigningMethod(SigningMethodHS512.Alg(), func() SigningMethod {
+ return SigningMethodHS512
+ })
+}
+
+func (m *SigningMethodHMAC) Alg() string {
+ return m.Name
+}
+
+// Verify the signature of HSXXX tokens. Returns nil if the signature is valid.
+func (m *SigningMethodHMAC) Verify(signingString, signature string, key interface{}) error {
+ // Verify the key is the right type
+ keyBytes, ok := key.([]byte)
+ if !ok {
+ return ErrInvalidKeyType
+ }
+
+ // Decode signature, for comparison
+ sig, err := DecodeSegment(signature)
+ if err != nil {
+ return err
+ }
+
+ // Can we use the specified hashing method?
+ if !m.Hash.Available() {
+ return ErrHashUnavailable
+ }
+
+ // This signing method is symmetric, so we validate the signature
+ // by reproducing the signature from the signing string and key, then
+ // comparing that against the provided signature.
+ hasher := hmac.New(m.Hash.New, keyBytes)
+ hasher.Write([]byte(signingString))
+ if !hmac.Equal(sig, hasher.Sum(nil)) {
+ return ErrSignatureInvalid
+ }
+
+ // No validation errors. Signature is good.
+ return nil
+}
+
+// Implements the Sign method from SigningMethod for this signing method.
+// Key must be []byte
+func (m *SigningMethodHMAC) Sign(signingString string, key interface{}) (string, error) {
+ if keyBytes, ok := key.([]byte); ok {
+ if !m.Hash.Available() {
+ return "", ErrHashUnavailable
+ }
+
+ hasher := hmac.New(m.Hash.New, keyBytes)
+ hasher.Write([]byte(signingString))
+
+ return EncodeSegment(hasher.Sum(nil)), nil
+ }
+
+ return "", ErrInvalidKeyType
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/map_claims.go b/vendor/github.com/dgrijalva/jwt-go/map_claims.go
new file mode 100644
index 0000000000..291213c460
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/map_claims.go
@@ -0,0 +1,94 @@
+package jwt
+
+import (
+ "encoding/json"
+ "errors"
+ // "fmt"
+)
+
+// Claims type that uses the map[string]interface{} for JSON decoding
+// This is the default claims type if you don't supply one
+type MapClaims map[string]interface{}
+
+// Compares the aud claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (m MapClaims) VerifyAudience(cmp string, req bool) bool {
+ aud, _ := m["aud"].(string)
+ return verifyAud(aud, cmp, req)
+}
+
+// Compares the exp claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (m MapClaims) VerifyExpiresAt(cmp int64, req bool) bool {
+ switch exp := m["exp"].(type) {
+ case float64:
+ return verifyExp(int64(exp), cmp, req)
+ case json.Number:
+ v, _ := exp.Int64()
+ return verifyExp(v, cmp, req)
+ }
+ return req == false
+}
+
+// Compares the iat claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (m MapClaims) VerifyIssuedAt(cmp int64, req bool) bool {
+ switch iat := m["iat"].(type) {
+ case float64:
+ return verifyIat(int64(iat), cmp, req)
+ case json.Number:
+ v, _ := iat.Int64()
+ return verifyIat(v, cmp, req)
+ }
+ return req == false
+}
+
+// Compares the iss claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (m MapClaims) VerifyIssuer(cmp string, req bool) bool {
+ iss, _ := m["iss"].(string)
+ return verifyIss(iss, cmp, req)
+}
+
+// Compares the nbf claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (m MapClaims) VerifyNotBefore(cmp int64, req bool) bool {
+ switch nbf := m["nbf"].(type) {
+ case float64:
+ return verifyNbf(int64(nbf), cmp, req)
+ case json.Number:
+ v, _ := nbf.Int64()
+ return verifyNbf(v, cmp, req)
+ }
+ return req == false
+}
+
+// Validates time based claims "exp, iat, nbf".
+// There is no accounting for clock skew.
+// As well, if any of the above claims are not in the token, it will still
+// be considered a valid claim.
+func (m MapClaims) Valid() error {
+ vErr := new(ValidationError)
+ now := TimeFunc().Unix()
+
+ if m.VerifyExpiresAt(now, false) == false {
+ vErr.Inner = errors.New("Token is expired")
+ vErr.Errors |= ValidationErrorExpired
+ }
+
+ if m.VerifyIssuedAt(now, false) == false {
+ vErr.Inner = errors.New("Token used before issued")
+ vErr.Errors |= ValidationErrorIssuedAt
+ }
+
+ if m.VerifyNotBefore(now, false) == false {
+ vErr.Inner = errors.New("Token is not valid yet")
+ vErr.Errors |= ValidationErrorNotValidYet
+ }
+
+ if vErr.valid() {
+ return nil
+ }
+
+ return vErr
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/none.go b/vendor/github.com/dgrijalva/jwt-go/none.go
new file mode 100644
index 0000000000..f04d189d06
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/none.go
@@ -0,0 +1,52 @@
+package jwt
+
+// Implements the none signing method. This is required by the spec
+// but you probably should never use it.
+var SigningMethodNone *signingMethodNone
+
+const UnsafeAllowNoneSignatureType unsafeNoneMagicConstant = "none signing method allowed"
+
+var NoneSignatureTypeDisallowedError error
+
+type signingMethodNone struct{}
+type unsafeNoneMagicConstant string
+
+func init() {
+ SigningMethodNone = &signingMethodNone{}
+ NoneSignatureTypeDisallowedError = NewValidationError("'none' signature type is not allowed", ValidationErrorSignatureInvalid)
+
+ RegisterSigningMethod(SigningMethodNone.Alg(), func() SigningMethod {
+ return SigningMethodNone
+ })
+}
+
+func (m *signingMethodNone) Alg() string {
+ return "none"
+}
+
+// Only allow 'none' alg type if UnsafeAllowNoneSignatureType is specified as the key
+func (m *signingMethodNone) Verify(signingString, signature string, key interface{}) (err error) {
+ // Key must be UnsafeAllowNoneSignatureType to prevent accidentally
+ // accepting 'none' signing method
+ if _, ok := key.(unsafeNoneMagicConstant); !ok {
+ return NoneSignatureTypeDisallowedError
+ }
+ // If signing method is none, signature must be an empty string
+ if signature != "" {
+ return NewValidationError(
+ "'none' signing method with non-empty signature",
+ ValidationErrorSignatureInvalid,
+ )
+ }
+
+ // Accept 'none' signing method.
+ return nil
+}
+
+// Only allow 'none' signing if UnsafeAllowNoneSignatureType is specified as the key
+func (m *signingMethodNone) Sign(signingString string, key interface{}) (string, error) {
+ if _, ok := key.(unsafeNoneMagicConstant); ok {
+ return "", nil
+ }
+ return "", NoneSignatureTypeDisallowedError
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/parser.go b/vendor/github.com/dgrijalva/jwt-go/parser.go
new file mode 100644
index 0000000000..d6901d9adb
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/parser.go
@@ -0,0 +1,148 @@
+package jwt
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "strings"
+)
+
+type Parser struct {
+ ValidMethods []string // If populated, only these methods will be considered valid
+ UseJSONNumber bool // Use JSON Number format in JSON decoder
+ SkipClaimsValidation bool // Skip claims validation during token parsing
+}
+
+// Parse, validate, and return a token.
+// keyFunc will receive the parsed token and should return the key for validating.
+// If everything is kosher, err will be nil
+func (p *Parser) Parse(tokenString string, keyFunc Keyfunc) (*Token, error) {
+ return p.ParseWithClaims(tokenString, MapClaims{}, keyFunc)
+}
+
+func (p *Parser) ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) {
+ token, parts, err := p.ParseUnverified(tokenString, claims)
+ if err != nil {
+ return token, err
+ }
+
+ // Verify signing method is in the required set
+ if p.ValidMethods != nil {
+ var signingMethodValid = false
+ var alg = token.Method.Alg()
+ for _, m := range p.ValidMethods {
+ if m == alg {
+ signingMethodValid = true
+ break
+ }
+ }
+ if !signingMethodValid {
+ // signing method is not in the listed set
+ return token, NewValidationError(fmt.Sprintf("signing method %v is invalid", alg), ValidationErrorSignatureInvalid)
+ }
+ }
+
+ // Lookup key
+ var key interface{}
+ if keyFunc == nil {
+ // keyFunc was not provided. short circuiting validation
+ return token, NewValidationError("no Keyfunc was provided.", ValidationErrorUnverifiable)
+ }
+ if key, err = keyFunc(token); err != nil {
+ // keyFunc returned an error
+ if ve, ok := err.(*ValidationError); ok {
+ return token, ve
+ }
+ return token, &ValidationError{Inner: err, Errors: ValidationErrorUnverifiable}
+ }
+
+ vErr := &ValidationError{}
+
+ // Validate Claims
+ if !p.SkipClaimsValidation {
+ if err := token.Claims.Valid(); err != nil {
+
+ // If the Claims Valid returned an error, check if it is a validation error,
+ // If it was another error type, create a ValidationError with a generic ClaimsInvalid flag set
+ if e, ok := err.(*ValidationError); !ok {
+ vErr = &ValidationError{Inner: err, Errors: ValidationErrorClaimsInvalid}
+ } else {
+ vErr = e
+ }
+ }
+ }
+
+ // Perform validation
+ token.Signature = parts[2]
+ if err = token.Method.Verify(strings.Join(parts[0:2], "."), token.Signature, key); err != nil {
+ vErr.Inner = err
+ vErr.Errors |= ValidationErrorSignatureInvalid
+ }
+
+ if vErr.valid() {
+ token.Valid = true
+ return token, nil
+ }
+
+ return token, vErr
+}
+
+// WARNING: Don't use this method unless you know what you're doing
+//
+// This method parses the token but doesn't validate the signature. It's only
+// ever useful in cases where you know the signature is valid (because it has
+// been checked previously in the stack) and you want to extract values from
+// it.
+func (p *Parser) ParseUnverified(tokenString string, claims Claims) (token *Token, parts []string, err error) {
+ parts = strings.Split(tokenString, ".")
+ if len(parts) != 3 {
+ return nil, parts, NewValidationError("token contains an invalid number of segments", ValidationErrorMalformed)
+ }
+
+ token = &Token{Raw: tokenString}
+
+ // parse Header
+ var headerBytes []byte
+ if headerBytes, err = DecodeSegment(parts[0]); err != nil {
+ if strings.HasPrefix(strings.ToLower(tokenString), "bearer ") {
+ return token, parts, NewValidationError("tokenstring should not contain 'bearer '", ValidationErrorMalformed)
+ }
+ return token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}
+ }
+ if err = json.Unmarshal(headerBytes, &token.Header); err != nil {
+ return token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}
+ }
+
+ // parse Claims
+ var claimBytes []byte
+ token.Claims = claims
+
+ if claimBytes, err = DecodeSegment(parts[1]); err != nil {
+ return token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}
+ }
+ dec := json.NewDecoder(bytes.NewBuffer(claimBytes))
+ if p.UseJSONNumber {
+ dec.UseNumber()
+ }
+ // JSON Decode. Special case for map type to avoid weird pointer behavior
+ if c, ok := token.Claims.(MapClaims); ok {
+ err = dec.Decode(&c)
+ } else {
+ err = dec.Decode(&claims)
+ }
+ // Handle decode error
+ if err != nil {
+ return token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}
+ }
+
+ // Lookup signature method
+ if method, ok := token.Header["alg"].(string); ok {
+ if token.Method = GetSigningMethod(method); token.Method == nil {
+ return token, parts, NewValidationError("signing method (alg) is unavailable.", ValidationErrorUnverifiable)
+ }
+ } else {
+ return token, parts, NewValidationError("signing method (alg) is unspecified.", ValidationErrorUnverifiable)
+ }
+
+ return token, parts, nil
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/rsa.go b/vendor/github.com/dgrijalva/jwt-go/rsa.go
new file mode 100644
index 0000000000..e4caf1ca4a
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/rsa.go
@@ -0,0 +1,101 @@
+package jwt
+
+import (
+ "crypto"
+ "crypto/rand"
+ "crypto/rsa"
+)
+
+// Implements the RSA family of signing methods signing methods
+// Expects *rsa.PrivateKey for signing and *rsa.PublicKey for validation
+type SigningMethodRSA struct {
+ Name string
+ Hash crypto.Hash
+}
+
+// Specific instances for RS256 and company
+var (
+ SigningMethodRS256 *SigningMethodRSA
+ SigningMethodRS384 *SigningMethodRSA
+ SigningMethodRS512 *SigningMethodRSA
+)
+
+func init() {
+ // RS256
+ SigningMethodRS256 = &SigningMethodRSA{"RS256", crypto.SHA256}
+ RegisterSigningMethod(SigningMethodRS256.Alg(), func() SigningMethod {
+ return SigningMethodRS256
+ })
+
+ // RS384
+ SigningMethodRS384 = &SigningMethodRSA{"RS384", crypto.SHA384}
+ RegisterSigningMethod(SigningMethodRS384.Alg(), func() SigningMethod {
+ return SigningMethodRS384
+ })
+
+ // RS512
+ SigningMethodRS512 = &SigningMethodRSA{"RS512", crypto.SHA512}
+ RegisterSigningMethod(SigningMethodRS512.Alg(), func() SigningMethod {
+ return SigningMethodRS512
+ })
+}
+
+func (m *SigningMethodRSA) Alg() string {
+ return m.Name
+}
+
+// Implements the Verify method from SigningMethod
+// For this signing method, must be an *rsa.PublicKey structure.
+func (m *SigningMethodRSA) Verify(signingString, signature string, key interface{}) error {
+ var err error
+
+ // Decode the signature
+ var sig []byte
+ if sig, err = DecodeSegment(signature); err != nil {
+ return err
+ }
+
+ var rsaKey *rsa.PublicKey
+ var ok bool
+
+ if rsaKey, ok = key.(*rsa.PublicKey); !ok {
+ return ErrInvalidKeyType
+ }
+
+ // Create hasher
+ if !m.Hash.Available() {
+ return ErrHashUnavailable
+ }
+ hasher := m.Hash.New()
+ hasher.Write([]byte(signingString))
+
+ // Verify the signature
+ return rsa.VerifyPKCS1v15(rsaKey, m.Hash, hasher.Sum(nil), sig)
+}
+
+// Implements the Sign method from SigningMethod
+// For this signing method, must be an *rsa.PrivateKey structure.
+func (m *SigningMethodRSA) Sign(signingString string, key interface{}) (string, error) {
+ var rsaKey *rsa.PrivateKey
+ var ok bool
+
+ // Validate type of key
+ if rsaKey, ok = key.(*rsa.PrivateKey); !ok {
+ return "", ErrInvalidKey
+ }
+
+ // Create the hasher
+ if !m.Hash.Available() {
+ return "", ErrHashUnavailable
+ }
+
+ hasher := m.Hash.New()
+ hasher.Write([]byte(signingString))
+
+ // Sign the string and return the encoded bytes
+ if sigBytes, err := rsa.SignPKCS1v15(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil)); err == nil {
+ return EncodeSegment(sigBytes), nil
+ } else {
+ return "", err
+ }
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/rsa_pss.go b/vendor/github.com/dgrijalva/jwt-go/rsa_pss.go
new file mode 100644
index 0000000000..10ee9db8a4
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/rsa_pss.go
@@ -0,0 +1,126 @@
+// +build go1.4
+
+package jwt
+
+import (
+ "crypto"
+ "crypto/rand"
+ "crypto/rsa"
+)
+
+// Implements the RSAPSS family of signing methods signing methods
+type SigningMethodRSAPSS struct {
+ *SigningMethodRSA
+ Options *rsa.PSSOptions
+}
+
+// Specific instances for RS/PS and company
+var (
+ SigningMethodPS256 *SigningMethodRSAPSS
+ SigningMethodPS384 *SigningMethodRSAPSS
+ SigningMethodPS512 *SigningMethodRSAPSS
+)
+
+func init() {
+ // PS256
+ SigningMethodPS256 = &SigningMethodRSAPSS{
+ &SigningMethodRSA{
+ Name: "PS256",
+ Hash: crypto.SHA256,
+ },
+ &rsa.PSSOptions{
+ SaltLength: rsa.PSSSaltLengthAuto,
+ Hash: crypto.SHA256,
+ },
+ }
+ RegisterSigningMethod(SigningMethodPS256.Alg(), func() SigningMethod {
+ return SigningMethodPS256
+ })
+
+ // PS384
+ SigningMethodPS384 = &SigningMethodRSAPSS{
+ &SigningMethodRSA{
+ Name: "PS384",
+ Hash: crypto.SHA384,
+ },
+ &rsa.PSSOptions{
+ SaltLength: rsa.PSSSaltLengthAuto,
+ Hash: crypto.SHA384,
+ },
+ }
+ RegisterSigningMethod(SigningMethodPS384.Alg(), func() SigningMethod {
+ return SigningMethodPS384
+ })
+
+ // PS512
+ SigningMethodPS512 = &SigningMethodRSAPSS{
+ &SigningMethodRSA{
+ Name: "PS512",
+ Hash: crypto.SHA512,
+ },
+ &rsa.PSSOptions{
+ SaltLength: rsa.PSSSaltLengthAuto,
+ Hash: crypto.SHA512,
+ },
+ }
+ RegisterSigningMethod(SigningMethodPS512.Alg(), func() SigningMethod {
+ return SigningMethodPS512
+ })
+}
+
+// Implements the Verify method from SigningMethod
+// For this verify method, key must be an rsa.PublicKey struct
+func (m *SigningMethodRSAPSS) Verify(signingString, signature string, key interface{}) error {
+ var err error
+
+ // Decode the signature
+ var sig []byte
+ if sig, err = DecodeSegment(signature); err != nil {
+ return err
+ }
+
+ var rsaKey *rsa.PublicKey
+ switch k := key.(type) {
+ case *rsa.PublicKey:
+ rsaKey = k
+ default:
+ return ErrInvalidKey
+ }
+
+ // Create hasher
+ if !m.Hash.Available() {
+ return ErrHashUnavailable
+ }
+ hasher := m.Hash.New()
+ hasher.Write([]byte(signingString))
+
+ return rsa.VerifyPSS(rsaKey, m.Hash, hasher.Sum(nil), sig, m.Options)
+}
+
+// Implements the Sign method from SigningMethod
+// For this signing method, key must be an rsa.PrivateKey struct
+func (m *SigningMethodRSAPSS) Sign(signingString string, key interface{}) (string, error) {
+ var rsaKey *rsa.PrivateKey
+
+ switch k := key.(type) {
+ case *rsa.PrivateKey:
+ rsaKey = k
+ default:
+ return "", ErrInvalidKeyType
+ }
+
+ // Create the hasher
+ if !m.Hash.Available() {
+ return "", ErrHashUnavailable
+ }
+
+ hasher := m.Hash.New()
+ hasher.Write([]byte(signingString))
+
+ // Sign the string and return the encoded bytes
+ if sigBytes, err := rsa.SignPSS(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil), m.Options); err == nil {
+ return EncodeSegment(sigBytes), nil
+ } else {
+ return "", err
+ }
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/rsa_utils.go b/vendor/github.com/dgrijalva/jwt-go/rsa_utils.go
new file mode 100644
index 0000000000..a5ababf956
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/rsa_utils.go
@@ -0,0 +1,101 @@
+package jwt
+
+import (
+ "crypto/rsa"
+ "crypto/x509"
+ "encoding/pem"
+ "errors"
+)
+
+var (
+ ErrKeyMustBePEMEncoded = errors.New("Invalid Key: Key must be PEM encoded PKCS1 or PKCS8 private key")
+ ErrNotRSAPrivateKey = errors.New("Key is not a valid RSA private key")
+ ErrNotRSAPublicKey = errors.New("Key is not a valid RSA public key")
+)
+
+// Parse PEM encoded PKCS1 or PKCS8 private key
+func ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error) {
+ var err error
+
+ // Parse PEM block
+ var block *pem.Block
+ if block, _ = pem.Decode(key); block == nil {
+ return nil, ErrKeyMustBePEMEncoded
+ }
+
+ var parsedKey interface{}
+ if parsedKey, err = x509.ParsePKCS1PrivateKey(block.Bytes); err != nil {
+ if parsedKey, err = x509.ParsePKCS8PrivateKey(block.Bytes); err != nil {
+ return nil, err
+ }
+ }
+
+ var pkey *rsa.PrivateKey
+ var ok bool
+ if pkey, ok = parsedKey.(*rsa.PrivateKey); !ok {
+ return nil, ErrNotRSAPrivateKey
+ }
+
+ return pkey, nil
+}
+
+// Parse PEM encoded PKCS1 or PKCS8 private key protected with password
+func ParseRSAPrivateKeyFromPEMWithPassword(key []byte, password string) (*rsa.PrivateKey, error) {
+ var err error
+
+ // Parse PEM block
+ var block *pem.Block
+ if block, _ = pem.Decode(key); block == nil {
+ return nil, ErrKeyMustBePEMEncoded
+ }
+
+ var parsedKey interface{}
+
+ var blockDecrypted []byte
+ if blockDecrypted, err = x509.DecryptPEMBlock(block, []byte(password)); err != nil {
+ return nil, err
+ }
+
+ if parsedKey, err = x509.ParsePKCS1PrivateKey(blockDecrypted); err != nil {
+ if parsedKey, err = x509.ParsePKCS8PrivateKey(blockDecrypted); err != nil {
+ return nil, err
+ }
+ }
+
+ var pkey *rsa.PrivateKey
+ var ok bool
+ if pkey, ok = parsedKey.(*rsa.PrivateKey); !ok {
+ return nil, ErrNotRSAPrivateKey
+ }
+
+ return pkey, nil
+}
+
+// Parse PEM encoded PKCS1 or PKCS8 public key
+func ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error) {
+ var err error
+
+ // Parse PEM block
+ var block *pem.Block
+ if block, _ = pem.Decode(key); block == nil {
+ return nil, ErrKeyMustBePEMEncoded
+ }
+
+ // Parse the key
+ var parsedKey interface{}
+ if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {
+ if cert, err := x509.ParseCertificate(block.Bytes); err == nil {
+ parsedKey = cert.PublicKey
+ } else {
+ return nil, err
+ }
+ }
+
+ var pkey *rsa.PublicKey
+ var ok bool
+ if pkey, ok = parsedKey.(*rsa.PublicKey); !ok {
+ return nil, ErrNotRSAPublicKey
+ }
+
+ return pkey, nil
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/signing_method.go b/vendor/github.com/dgrijalva/jwt-go/signing_method.go
new file mode 100644
index 0000000000..ed1f212b21
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/signing_method.go
@@ -0,0 +1,35 @@
+package jwt
+
+import (
+ "sync"
+)
+
+var signingMethods = map[string]func() SigningMethod{}
+var signingMethodLock = new(sync.RWMutex)
+
+// Implement SigningMethod to add new methods for signing or verifying tokens.
+type SigningMethod interface {
+ Verify(signingString, signature string, key interface{}) error // Returns nil if signature is valid
+ Sign(signingString string, key interface{}) (string, error) // Returns encoded signature or error
+ Alg() string // returns the alg identifier for this method (example: 'HS256')
+}
+
+// Register the "alg" name and a factory function for signing method.
+// This is typically done during init() in the method's implementation
+func RegisterSigningMethod(alg string, f func() SigningMethod) {
+ signingMethodLock.Lock()
+ defer signingMethodLock.Unlock()
+
+ signingMethods[alg] = f
+}
+
+// Get a signing method from an "alg" string
+func GetSigningMethod(alg string) (method SigningMethod) {
+ signingMethodLock.RLock()
+ defer signingMethodLock.RUnlock()
+
+ if methodF, ok := signingMethods[alg]; ok {
+ method = methodF()
+ }
+ return
+}
diff --git a/vendor/github.com/dgrijalva/jwt-go/token.go b/vendor/github.com/dgrijalva/jwt-go/token.go
new file mode 100644
index 0000000000..d637e0867c
--- /dev/null
+++ b/vendor/github.com/dgrijalva/jwt-go/token.go
@@ -0,0 +1,108 @@
+package jwt
+
+import (
+ "encoding/base64"
+ "encoding/json"
+ "strings"
+ "time"
+)
+
+// TimeFunc provides the current time when parsing token to validate "exp" claim (expiration time).
+// You can override it to use another time value. This is useful for testing or if your
+// server uses a different time zone than your tokens.
+var TimeFunc = time.Now
+
+// Parse methods use this callback function to supply
+// the key for verification. The function receives the parsed,
+// but unverified Token. This allows you to use properties in the
+// Header of the token (such as `kid`) to identify which key to use.
+type Keyfunc func(*Token) (interface{}, error)
+
+// A JWT Token. Different fields will be used depending on whether you're
+// creating or parsing/verifying a token.
+type Token struct {
+ Raw string // The raw token. Populated when you Parse a token
+ Method SigningMethod // The signing method used or to be used
+ Header map[string]interface{} // The first segment of the token
+ Claims Claims // The second segment of the token
+ Signature string // The third segment of the token. Populated when you Parse a token
+ Valid bool // Is the token valid? Populated when you Parse/Verify a token
+}
+
+// Create a new Token. Takes a signing method
+func New(method SigningMethod) *Token {
+ return NewWithClaims(method, MapClaims{})
+}
+
+func NewWithClaims(method SigningMethod, claims Claims) *Token {
+ return &Token{
+ Header: map[string]interface{}{
+ "typ": "JWT",
+ "alg": method.Alg(),
+ },
+ Claims: claims,
+ Method: method,
+ }
+}
+
+// Get the complete, signed token
+func (t *Token) SignedString(key interface{}) (string, error) {
+ var sig, sstr string
+ var err error
+ if sstr, err = t.SigningString(); err != nil {
+ return "", err
+ }
+ if sig, err = t.Method.Sign(sstr, key); err != nil {
+ return "", err
+ }
+ return strings.Join([]string{sstr, sig}, "."), nil
+}
+
+// Generate the signing string. This is the
+// most expensive part of the whole deal. Unless you
+// need this for something special, just go straight for
+// the SignedString.
+func (t *Token) SigningString() (string, error) {
+ var err error
+ parts := make([]string, 2)
+ for i, _ := range parts {
+ var jsonValue []byte
+ if i == 0 {
+ if jsonValue, err = json.Marshal(t.Header); err != nil {
+ return "", err
+ }
+ } else {
+ if jsonValue, err = json.Marshal(t.Claims); err != nil {
+ return "", err
+ }
+ }
+
+ parts[i] = EncodeSegment(jsonValue)
+ }
+ return strings.Join(parts, "."), nil
+}
+
+// Parse, validate, and return a token.
+// keyFunc will receive the parsed token and should return the key for validating.
+// If everything is kosher, err will be nil
+func Parse(tokenString string, keyFunc Keyfunc) (*Token, error) {
+ return new(Parser).Parse(tokenString, keyFunc)
+}
+
+func ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) {
+ return new(Parser).ParseWithClaims(tokenString, claims, keyFunc)
+}
+
+// Encode JWT specific base64url encoding with padding stripped
+func EncodeSegment(seg []byte) string {
+ return strings.TrimRight(base64.URLEncoding.EncodeToString(seg), "=")
+}
+
+// Decode JWT specific base64url encoding with padding stripped
+func DecodeSegment(seg string) ([]byte, error) {
+ if l := len(seg) % 4; l > 0 {
+ seg += strings.Repeat("=", 4-l)
+ }
+
+ return base64.URLEncoding.DecodeString(seg)
+}
diff --git a/vendor/github.com/dimchansky/utfbom/.gitignore b/vendor/github.com/dimchansky/utfbom/.gitignore
new file mode 100644
index 0000000000..d7ec5cebb9
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/.gitignore
@@ -0,0 +1,37 @@
+# Binaries for programs and plugins
+*.exe
+*.dll
+*.so
+*.dylib
+*.o
+*.a
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.prof
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
+.glide/
+
+# Gogland
+.idea/
\ No newline at end of file
diff --git a/vendor/github.com/dimchansky/utfbom/.travis.yml b/vendor/github.com/dimchansky/utfbom/.travis.yml
new file mode 100644
index 0000000000..b2e420c0d6
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/.travis.yml
@@ -0,0 +1,18 @@
+language: go
+
+go:
+ - '1.10'
+ - '1.11'
+
+# sudo=false makes the build run using a container
+sudo: false
+
+before_install:
+ - go get github.com/mattn/goveralls
+ - go get golang.org/x/tools/cmd/cover
+ - go get golang.org/x/tools/cmd/goimports
+ - go get github.com/golang/lint/golint
+script:
+ - gofiles=$(find ./ -name '*.go') && [ -z "$gofiles" ] || unformatted=$(goimports -l $gofiles) && [ -z "$unformatted" ] || (echo >&2 "Go files must be formatted with gofmt. Following files has problem:\n $unformatted" && false)
+ - golint ./... # This won't break the build, just show warnings
+ - $HOME/gopath/bin/goveralls -service=travis-ci
diff --git a/vendor/github.com/dimchansky/utfbom/LICENSE b/vendor/github.com/dimchansky/utfbom/LICENSE
new file mode 100644
index 0000000000..8dada3edaf
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/LICENSE
@@ -0,0 +1,201 @@
+ 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.
diff --git a/vendor/github.com/dimchansky/utfbom/README.md b/vendor/github.com/dimchansky/utfbom/README.md
new file mode 100644
index 0000000000..8ece280089
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/README.md
@@ -0,0 +1,66 @@
+# utfbom [](https://godoc.org/github.com/dimchansky/utfbom) [](https://opensource.org/licenses/Apache-2.0) [](https://travis-ci.org/dimchansky/utfbom) [](https://goreportcard.com/report/github.com/dimchansky/utfbom) [](https://coveralls.io/github/dimchansky/utfbom?branch=master)
+
+The package utfbom implements the detection of the BOM (Unicode Byte Order Mark) and removing as necessary. It can also return the encoding detected by the BOM.
+
+## Installation
+
+ go get -u github.com/dimchansky/utfbom
+
+## Example
+
+```go
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "io/ioutil"
+
+ "github.com/dimchansky/utfbom"
+)
+
+func main() {
+ trySkip([]byte("\xEF\xBB\xBFhello"))
+ trySkip([]byte("hello"))
+}
+
+func trySkip(byteData []byte) {
+ fmt.Println("Input:", byteData)
+
+ // just skip BOM
+ output, err := ioutil.ReadAll(utfbom.SkipOnly(bytes.NewReader(byteData)))
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ fmt.Println("ReadAll with BOM skipping", output)
+
+ // skip BOM and detect encoding
+ sr, enc := utfbom.Skip(bytes.NewReader(byteData))
+ fmt.Printf("Detected encoding: %s\n", enc)
+ output, err = ioutil.ReadAll(sr)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ fmt.Println("ReadAll with BOM detection and skipping", output)
+ fmt.Println()
+}
+```
+
+Output:
+
+```
+$ go run main.go
+Input: [239 187 191 104 101 108 108 111]
+ReadAll with BOM skipping [104 101 108 108 111]
+Detected encoding: UTF8
+ReadAll with BOM detection and skipping [104 101 108 108 111]
+
+Input: [104 101 108 108 111]
+ReadAll with BOM skipping [104 101 108 108 111]
+Detected encoding: Unknown
+ReadAll with BOM detection and skipping [104 101 108 108 111]
+```
+
+
diff --git a/vendor/github.com/dimchansky/utfbom/go.mod b/vendor/github.com/dimchansky/utfbom/go.mod
new file mode 100644
index 0000000000..4b9ecc6f54
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/go.mod
@@ -0,0 +1 @@
+module github.com/dimchansky/utfbom
\ No newline at end of file
diff --git a/vendor/github.com/dimchansky/utfbom/utfbom.go b/vendor/github.com/dimchansky/utfbom/utfbom.go
new file mode 100644
index 0000000000..77a303e564
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/utfbom.go
@@ -0,0 +1,192 @@
+// Package utfbom implements the detection of the BOM (Unicode Byte Order Mark) and removing as necessary.
+// It wraps an io.Reader object, creating another object (Reader) that also implements the io.Reader
+// interface but provides automatic BOM checking and removing as necessary.
+package utfbom
+
+import (
+ "errors"
+ "io"
+)
+
+// Encoding is type alias for detected UTF encoding.
+type Encoding int
+
+// Constants to identify detected UTF encodings.
+const (
+ // Unknown encoding, returned when no BOM was detected
+ Unknown Encoding = iota
+
+ // UTF8, BOM bytes: EF BB BF
+ UTF8
+
+ // UTF-16, big-endian, BOM bytes: FE FF
+ UTF16BigEndian
+
+ // UTF-16, little-endian, BOM bytes: FF FE
+ UTF16LittleEndian
+
+ // UTF-32, big-endian, BOM bytes: 00 00 FE FF
+ UTF32BigEndian
+
+ // UTF-32, little-endian, BOM bytes: FF FE 00 00
+ UTF32LittleEndian
+)
+
+// String returns a user-friendly string representation of the encoding. Satisfies fmt.Stringer interface.
+func (e Encoding) String() string {
+ switch e {
+ case UTF8:
+ return "UTF8"
+ case UTF16BigEndian:
+ return "UTF16BigEndian"
+ case UTF16LittleEndian:
+ return "UTF16LittleEndian"
+ case UTF32BigEndian:
+ return "UTF32BigEndian"
+ case UTF32LittleEndian:
+ return "UTF32LittleEndian"
+ default:
+ return "Unknown"
+ }
+}
+
+const maxConsecutiveEmptyReads = 100
+
+// Skip creates Reader which automatically detects BOM (Unicode Byte Order Mark) and removes it as necessary.
+// It also returns the encoding detected by the BOM.
+// If the detected encoding is not needed, you can call the SkipOnly function.
+func Skip(rd io.Reader) (*Reader, Encoding) {
+ // Is it already a Reader?
+ b, ok := rd.(*Reader)
+ if ok {
+ return b, Unknown
+ }
+
+ enc, left, err := detectUtf(rd)
+ return &Reader{
+ rd: rd,
+ buf: left,
+ err: err,
+ }, enc
+}
+
+// SkipOnly creates Reader which automatically detects BOM (Unicode Byte Order Mark) and removes it as necessary.
+func SkipOnly(rd io.Reader) *Reader {
+ r, _ := Skip(rd)
+ return r
+}
+
+// Reader implements automatic BOM (Unicode Byte Order Mark) checking and
+// removing as necessary for an io.Reader object.
+type Reader struct {
+ rd io.Reader // reader provided by the client
+ buf []byte // buffered data
+ err error // last error
+}
+
+// Read is an implementation of io.Reader interface.
+// The bytes are taken from the underlying Reader, but it checks for BOMs, removing them as necessary.
+func (r *Reader) Read(p []byte) (n int, err error) {
+ if len(p) == 0 {
+ return 0, nil
+ }
+
+ if r.buf == nil {
+ if r.err != nil {
+ return 0, r.readErr()
+ }
+
+ return r.rd.Read(p)
+ }
+
+ // copy as much as we can
+ n = copy(p, r.buf)
+ r.buf = nilIfEmpty(r.buf[n:])
+ return n, nil
+}
+
+func (r *Reader) readErr() error {
+ err := r.err
+ r.err = nil
+ return err
+}
+
+var errNegativeRead = errors.New("utfbom: reader returned negative count from Read")
+
+func detectUtf(rd io.Reader) (enc Encoding, buf []byte, err error) {
+ buf, err = readBOM(rd)
+
+ if len(buf) >= 4 {
+ if isUTF32BigEndianBOM4(buf) {
+ return UTF32BigEndian, nilIfEmpty(buf[4:]), err
+ }
+ if isUTF32LittleEndianBOM4(buf) {
+ return UTF32LittleEndian, nilIfEmpty(buf[4:]), err
+ }
+ }
+
+ if len(buf) > 2 && isUTF8BOM3(buf) {
+ return UTF8, nilIfEmpty(buf[3:]), err
+ }
+
+ if (err != nil && err != io.EOF) || (len(buf) < 2) {
+ return Unknown, nilIfEmpty(buf), err
+ }
+
+ if isUTF16BigEndianBOM2(buf) {
+ return UTF16BigEndian, nilIfEmpty(buf[2:]), err
+ }
+ if isUTF16LittleEndianBOM2(buf) {
+ return UTF16LittleEndian, nilIfEmpty(buf[2:]), err
+ }
+
+ return Unknown, nilIfEmpty(buf), err
+}
+
+func readBOM(rd io.Reader) (buf []byte, err error) {
+ const maxBOMSize = 4
+ var bom [maxBOMSize]byte // used to read BOM
+
+ // read as many bytes as possible
+ for nEmpty, n := 0, 0; err == nil && len(buf) < maxBOMSize; buf = bom[:len(buf)+n] {
+ if n, err = rd.Read(bom[len(buf):]); n < 0 {
+ panic(errNegativeRead)
+ }
+ if n > 0 {
+ nEmpty = 0
+ } else {
+ nEmpty++
+ if nEmpty >= maxConsecutiveEmptyReads {
+ err = io.ErrNoProgress
+ }
+ }
+ }
+ return
+}
+
+func isUTF32BigEndianBOM4(buf []byte) bool {
+ return buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0xFE && buf[3] == 0xFF
+}
+
+func isUTF32LittleEndianBOM4(buf []byte) bool {
+ return buf[0] == 0xFF && buf[1] == 0xFE && buf[2] == 0x00 && buf[3] == 0x00
+}
+
+func isUTF8BOM3(buf []byte) bool {
+ return buf[0] == 0xEF && buf[1] == 0xBB && buf[2] == 0xBF
+}
+
+func isUTF16BigEndianBOM2(buf []byte) bool {
+ return buf[0] == 0xFE && buf[1] == 0xFF
+}
+
+func isUTF16LittleEndianBOM2(buf []byte) bool {
+ return buf[0] == 0xFF && buf[1] == 0xFE
+}
+
+func nilIfEmpty(buf []byte) (res []byte) {
+ if len(buf) > 0 {
+ res = buf
+ }
+ return
+}
diff --git a/vendor/github.com/dnaeon/go-vcr/LICENSE b/vendor/github.com/dnaeon/go-vcr/LICENSE
new file mode 100644
index 0000000000..9a46132086
--- /dev/null
+++ b/vendor/github.com/dnaeon/go-vcr/LICENSE
@@ -0,0 +1,24 @@
+Copyright (c) 2015-2016 Marin Atanasov Nikolov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer
+ in this position and unchanged.
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/dnaeon/go-vcr/cassette/cassette.go b/vendor/github.com/dnaeon/go-vcr/cassette/cassette.go
new file mode 100644
index 0000000000..cf9e340d30
--- /dev/null
+++ b/vendor/github.com/dnaeon/go-vcr/cassette/cassette.go
@@ -0,0 +1,227 @@
+// Copyright (c) 2015 Marin Atanasov Nikolov
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer
+// in this position and unchanged.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package cassette
+
+import (
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "os"
+ "path/filepath"
+ "sync"
+
+ "gopkg.in/yaml.v2"
+)
+
+// Cassette format versions
+const (
+ cassetteFormatV1 = 1
+)
+
+var (
+ // ErrInteractionNotFound indicates that a requested
+ // interaction was not found in the cassette file
+ ErrInteractionNotFound = errors.New("Requested interaction not found")
+)
+
+// Request represents a client request as recorded in the
+// cassette file
+type Request struct {
+ // Body of request
+ Body string `yaml:"body"`
+
+ // Form values
+ Form url.Values `yaml:"form"`
+
+ // Request headers
+ Headers http.Header `yaml:"headers"`
+
+ // Request URL
+ URL string `yaml:"url"`
+
+ // Request method
+ Method string `yaml:"method"`
+}
+
+// Response represents a server response as recorded in the
+// cassette file
+type Response struct {
+ // Body of response
+ Body string `yaml:"body"`
+
+ // Response headers
+ Headers http.Header `yaml:"headers"`
+
+ // Response status message
+ Status string `yaml:"status"`
+
+ // Response status code
+ Code int `yaml:"code"`
+
+ // Response duration (something like "100ms" or "10s")
+ Duration string `yaml:"duration"`
+
+ replayed bool
+}
+
+// Interaction type contains a pair of request/response for a
+// single HTTP interaction between a client and a server
+type Interaction struct {
+ Request `yaml:"request"`
+ Response `yaml:"response"`
+}
+
+// Matcher function returns true when the actual request matches
+// a single HTTP interaction's request according to the function's
+// own criteria.
+type Matcher func(*http.Request, Request) bool
+
+// DefaultMatcher is used when a custom matcher is not defined
+// and compares only the method and URL.
+func DefaultMatcher(r *http.Request, i Request) bool {
+ return r.Method == i.Method && r.URL.String() == i.URL
+}
+
+// Filter function allows modification of an interaction before saving.
+type Filter func(*Interaction) error
+
+// Cassette type
+type Cassette struct {
+ // Name of the cassette
+ Name string `yaml:"-"`
+
+ // File name of the cassette as written on disk
+ File string `yaml:"-"`
+
+ // Cassette format version
+ Version int `yaml:"version"`
+
+ // Mutex to lock accessing Interactions. omitempty is set
+ // to prevent the mutex appearing in the recorded YAML.
+ Mu sync.RWMutex `yaml:"mu,omitempty"`
+ // Interactions between client and server
+ Interactions []*Interaction `yaml:"interactions"`
+
+ // Matches actual request with interaction requests.
+ Matcher Matcher `yaml:"-"`
+
+ // Filters interactions before being saved.
+ Filters []Filter `yaml:"-"`
+}
+
+// New creates a new empty cassette
+func New(name string) *Cassette {
+ c := &Cassette{
+ Name: name,
+ File: fmt.Sprintf("%s.yaml", name),
+ Version: cassetteFormatV1,
+ Interactions: make([]*Interaction, 0),
+ Matcher: DefaultMatcher,
+ Filters: make([]Filter, 0),
+ }
+
+ return c
+}
+
+// Load reads a cassette file from disk
+func Load(name string) (*Cassette, error) {
+ c := New(name)
+ data, err := ioutil.ReadFile(c.File)
+ if err != nil {
+ return nil, err
+ }
+
+ err = yaml.Unmarshal(data, &c)
+
+ return c, err
+}
+
+// AddInteraction appends a new interaction to the cassette
+func (c *Cassette) AddInteraction(i *Interaction) {
+ c.Mu.Lock()
+ c.Interactions = append(c.Interactions, i)
+ c.Mu.Unlock()
+}
+
+// GetInteraction retrieves a recorded request/response interaction
+func (c *Cassette) GetInteraction(r *http.Request) (*Interaction, error) {
+ c.Mu.Lock()
+ defer c.Mu.Unlock()
+ for _, i := range c.Interactions {
+ if !i.replayed && c.Matcher(r, i.Request) {
+ i.replayed = true
+ return i, nil
+ }
+ }
+
+ return nil, ErrInteractionNotFound
+}
+
+// Save writes the cassette data on disk for future re-use
+func (c *Cassette) Save() error {
+ c.Mu.RLock()
+ defer c.Mu.RUnlock()
+ // Save cassette file only if there were any interactions made
+ if len(c.Interactions) == 0 {
+ return nil
+ }
+
+ // Create directory for cassette if missing
+ cassetteDir := filepath.Dir(c.File)
+ if _, err := os.Stat(cassetteDir); os.IsNotExist(err) {
+ if err = os.MkdirAll(cassetteDir, 0755); err != nil {
+ return err
+ }
+ }
+
+ // Marshal to YAML and save interactions
+ data, err := yaml.Marshal(c)
+ if err != nil {
+ return err
+ }
+
+ f, err := os.Create(c.File)
+ if err != nil {
+ return err
+ }
+
+ defer f.Close()
+
+ // Honor the YAML structure specification
+ // http://www.yaml.org/spec/1.2/spec.html#id2760395
+ _, err = f.Write([]byte("---\n"))
+ if err != nil {
+ return err
+ }
+
+ _, err = f.Write(data)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/dnaeon/go-vcr/recorder/go17_nobody.go b/vendor/github.com/dnaeon/go-vcr/recorder/go17_nobody.go
new file mode 100644
index 0000000000..465961abbf
--- /dev/null
+++ b/vendor/github.com/dnaeon/go-vcr/recorder/go17_nobody.go
@@ -0,0 +1,37 @@
+// Copyright (c) 2015-2016 Marin Atanasov Nikolov
+// Copyright (c) 2016 David Jack
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer
+// in this position and unchanged.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// +build !go1.8
+
+package recorder
+
+import (
+ "io"
+)
+
+// isNoBody returns true iff r is an http.NoBody.
+// http.NoBody didn't exist before Go 1.7, so the version in this file
+// always returns false.
+func isNoBody(r io.ReadCloser) bool { return false }
diff --git a/vendor/github.com/dnaeon/go-vcr/recorder/go18_nobody.go b/vendor/github.com/dnaeon/go-vcr/recorder/go18_nobody.go
new file mode 100644
index 0000000000..dac213af8f
--- /dev/null
+++ b/vendor/github.com/dnaeon/go-vcr/recorder/go18_nobody.go
@@ -0,0 +1,36 @@
+// Copyright (c) 2015-2016 Marin Atanasov Nikolov
+// Copyright (c) 2016 David Jack
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer
+// in this position and unchanged.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// +build go1.8
+
+package recorder
+
+import (
+ "io"
+ "net/http"
+)
+
+// isNoBody returns true iff r is an http.NoBody.
+func isNoBody(r io.ReadCloser) bool { return r == http.NoBody }
diff --git a/vendor/github.com/dnaeon/go-vcr/recorder/recorder.go b/vendor/github.com/dnaeon/go-vcr/recorder/recorder.go
new file mode 100644
index 0000000000..2b88919526
--- /dev/null
+++ b/vendor/github.com/dnaeon/go-vcr/recorder/recorder.go
@@ -0,0 +1,275 @@
+// Copyright (c) 2015-2016 Marin Atanasov Nikolov
+// Copyright (c) 2016 David Jack
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer
+// in this position and unchanged.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package recorder
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/http/httputil"
+ "os"
+ "strconv"
+ "time"
+
+ "github.com/dnaeon/go-vcr/cassette"
+)
+
+// Mode represents recording/playback mode
+type Mode int
+
+// Recorder states
+const (
+ ModeRecording Mode = iota
+ ModeReplaying
+ ModeDisabled
+)
+
+// Recorder represents a type used to record and replay
+// client and server interactions
+type Recorder struct {
+ // Operating mode of the recorder
+ mode Mode
+
+ // Cassette used by the recorder
+ cassette *cassette.Cassette
+
+ // realTransport is the underlying http.RoundTripper to make real requests
+ realTransport http.RoundTripper
+}
+
+// SetTransport can be used to configure the behavior of the 'real' client used in record-mode
+func (r *Recorder) SetTransport(t http.RoundTripper) {
+ r.realTransport = t
+}
+
+// Proxies client requests to their original destination
+func requestHandler(r *http.Request, c *cassette.Cassette, mode Mode, realTransport http.RoundTripper) (*cassette.Interaction, error) {
+ // Return interaction from cassette if in replay mode
+ if mode == ModeReplaying {
+ if err := r.Context().Err(); err != nil {
+ return nil, err
+ }
+ return c.GetInteraction(r)
+ }
+
+ // Copy the original request, so we can read the form values
+ reqBytes, err := httputil.DumpRequestOut(r, true)
+ if err != nil {
+ return nil, err
+ }
+
+ reqBuffer := bytes.NewBuffer(reqBytes)
+ copiedReq, err := http.ReadRequest(bufio.NewReader(reqBuffer))
+ if err != nil {
+ return nil, err
+ }
+
+ err = copiedReq.ParseForm()
+ if err != nil {
+ return nil, err
+ }
+
+ reqBody := &bytes.Buffer{}
+ if r.Body != nil && !isNoBody(r.Body) {
+ // Record the request body so we can add it to the cassette
+ r.Body = ioutil.NopCloser(io.TeeReader(r.Body, reqBody))
+ }
+
+ // Perform client request to it's original
+ // destination and record interactions
+ resp, err := realTransport.RoundTrip(r)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ respBody, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+
+ // Add interaction to cassette
+ interaction := &cassette.Interaction{
+ Request: cassette.Request{
+ Body: reqBody.String(),
+ Form: copiedReq.PostForm,
+ Headers: r.Header,
+ URL: r.URL.String(),
+ Method: r.Method,
+ },
+ Response: cassette.Response{
+ Body: string(respBody),
+ Headers: resp.Header,
+ Status: resp.Status,
+ Code: resp.StatusCode,
+ },
+ }
+ for _, filter := range c.Filters {
+ err = filter(interaction)
+ if err != nil {
+ return nil, err
+ }
+ }
+ c.AddInteraction(interaction)
+
+ return interaction, nil
+}
+
+// New creates a new recorder
+func New(cassetteName string) (*Recorder, error) {
+ // Default mode is "replay" if file exists
+ return NewAsMode(cassetteName, ModeReplaying, nil)
+}
+
+// NewAsMode creates a new recorder in the specified mode
+func NewAsMode(cassetteName string, mode Mode, realTransport http.RoundTripper) (*Recorder, error) {
+ var c *cassette.Cassette
+ cassetteFile := fmt.Sprintf("%s.yaml", cassetteName)
+
+ if mode != ModeDisabled {
+ // Depending on whether the cassette file exists or not we
+ // either create a new empty cassette or load from file
+ if _, err := os.Stat(cassetteFile); os.IsNotExist(err) || mode == ModeRecording {
+ // Create new cassette and enter in recording mode
+ c = cassette.New(cassetteName)
+ mode = ModeRecording
+ } else {
+ // Load cassette from file and enter replay mode
+ c, err = cassette.Load(cassetteName)
+ if err != nil {
+ return nil, err
+ }
+ mode = ModeReplaying
+ }
+ }
+
+ if realTransport == nil {
+ realTransport = http.DefaultTransport
+ }
+
+ r := &Recorder{
+ mode: mode,
+ cassette: c,
+ realTransport: realTransport,
+ }
+
+ return r, nil
+}
+
+// Stop is used to stop the recorder and save any recorded interactions
+func (r *Recorder) Stop() error {
+ if r.mode == ModeRecording {
+ if err := r.cassette.Save(); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// RoundTrip implements the http.RoundTripper interface
+func (r *Recorder) RoundTrip(req *http.Request) (*http.Response, error) {
+ if r.mode == ModeDisabled {
+ return r.realTransport.RoundTrip(req)
+ }
+ // Pass cassette and mode to handler, so that interactions can be
+ // retrieved or recorded depending on the current recorder mode
+ interaction, err := requestHandler(req, r.cassette, r.mode, r.realTransport)
+
+ if err != nil {
+ return nil, err
+ }
+
+ select {
+ case <-req.Context().Done():
+ return nil, req.Context().Err()
+ default:
+ buf := bytes.NewBuffer([]byte(interaction.Response.Body))
+ // apply the duration defined in the interaction
+ if interaction.Response.Duration != "" {
+ d, err := time.ParseDuration(interaction.Duration)
+ if err != nil {
+ return nil, err
+ }
+ // block for the configured 'duration' to simulate the network latency and server processing time.
+ <-time.After(d)
+ }
+
+ contentLength := int64(buf.Len())
+ // For HTTP HEAD requests, the ContentLength should be set to the size
+ // of the body that would have been sent for a GET.
+ // https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.13
+ if req.Method == "HEAD" {
+ if hdr := interaction.Response.Headers.Get("Content-Length"); hdr != "" {
+ cl, err := strconv.ParseInt(hdr, 10, 64)
+ if err == nil {
+ contentLength = cl
+ }
+ }
+ }
+ return &http.Response{
+ Status: interaction.Response.Status,
+ StatusCode: interaction.Response.Code,
+ Proto: "HTTP/1.0",
+ ProtoMajor: 1,
+ ProtoMinor: 0,
+ Request: req,
+ Header: interaction.Response.Headers,
+ Close: true,
+ ContentLength: contentLength,
+ Body: ioutil.NopCloser(buf),
+ }, nil
+ }
+}
+
+// CancelRequest implements the github.com/coreos/etcd/client.CancelableTransport interface
+func (r *Recorder) CancelRequest(req *http.Request) {
+ type cancelableTransport interface {
+ CancelRequest(req *http.Request)
+ }
+ if ct, ok := r.realTransport.(cancelableTransport); ok {
+ ct.CancelRequest(req)
+ }
+}
+
+// SetMatcher sets a function to match requests against recorded HTTP interactions.
+func (r *Recorder) SetMatcher(matcher cassette.Matcher) {
+ if r.cassette != nil {
+ r.cassette.Matcher = matcher
+ }
+}
+
+// AddFilter appends a hook to modify a request before it is recorded.
+//
+// Filters are useful for filtering out sensitive parameters from the recorded data.
+func (r *Recorder) AddFilter(filter cassette.Filter) {
+ if r.cassette != nil {
+ r.cassette.Filters = append(r.cassette.Filters, filter)
+ }
+}
diff --git a/vendor/github.com/globalsign/mgo/.gitignore b/vendor/github.com/globalsign/mgo/.gitignore
new file mode 100644
index 0000000000..9a3120f6bf
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/.gitignore
@@ -0,0 +1,2 @@
+_harness
+.vscode
\ No newline at end of file
diff --git a/vendor/github.com/globalsign/mgo/.travis.yml b/vendor/github.com/globalsign/mgo/.travis.yml
new file mode 100644
index 0000000000..f1f89e966b
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/.travis.yml
@@ -0,0 +1,49 @@
+language: go
+
+go_import_path: github.com/globalsign/mgo
+
+go:
+ - 1.9.x
+ - 1.10.x
+
+env:
+ global:
+ - BUCKET=https://s3.eu-west-2.amazonaws.com/globalsign-mgo
+ - FASTDL=https://fastdl.mongodb.org/linux
+ matrix:
+ - MONGODB=x86_64-ubuntu1404-3.0.15
+ - MONGODB=x86_64-ubuntu1404-3.2.17
+ - MONGODB=x86_64-ubuntu1404-3.4.10
+ - MONGODB=x86_64-ubuntu1404-3.6.0
+
+install:
+
+ - wget $FASTDL/mongodb-linux-$MONGODB.tgz
+ - tar xzvf mongodb-linux-$MONGODB.tgz
+ - export PATH=$PWD/mongodb-linux-$MONGODB/bin:$PATH
+
+ - wget $BUCKET/daemontools.tar.gz
+ - tar xzvf daemontools.tar.gz
+ - export PATH=$PWD/daemontools:$PATH
+
+ - go get gopkg.in/check.v1
+ - go get gopkg.in/yaml.v2
+ - go get gopkg.in/tomb.v2
+ - go get golang.org/x/lint/golint
+
+before_script:
+ - golint ./... | grep -v 'ID' | cat
+ - go vet github.com/globalsign/mgo/bson github.com/globalsign/mgo/txn github.com/globalsign/mgo
+ - export NOIPV6=1
+ - make startdb
+
+script:
+ - (cd bson && go test -check.v)
+ - go test -check.v -fast
+ - (cd txn && go test -check.v)
+ - make stopdb
+
+git:
+ depth: 3
+
+# vim:sw=4:ts=4:et
diff --git a/vendor/github.com/globalsign/mgo/CONTRIBUTING.md b/vendor/github.com/globalsign/mgo/CONTRIBUTING.md
new file mode 100644
index 0000000000..7953995500
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/CONTRIBUTING.md
@@ -0,0 +1,14 @@
+Contributing
+-------------------------
+
+We really appreciate contributions, but they must meet the following requirements:
+
+* A PR should have a brief description of the problem/feature being proposed
+* Pull requests should target the `development` branch
+* Existing tests should pass and any new code should be covered with it's own test(s) (use [travis-ci](https://travis-ci.org))
+* New functions should be [documented](https://blog.golang.org/godoc-documenting-go-code) clearly
+* Code should pass `golint`, `go vet` and `go fmt`
+
+We merge PRs into `development`, which is then tested in a sharded, replicated environment in our datacenter for regressions. Once everyone is happy, we merge to master - this is to maintain a bit of quality control past the usual PR process.
+
+**Thanks** for helping!
diff --git a/vendor/github.com/globalsign/mgo/LICENSE b/vendor/github.com/globalsign/mgo/LICENSE
new file mode 100644
index 0000000000..770c7672b4
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/LICENSE
@@ -0,0 +1,25 @@
+mgo - MongoDB driver for Go
+
+Copyright (c) 2010-2013 - Gustavo Niemeyer
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/globalsign/mgo/Makefile b/vendor/github.com/globalsign/mgo/Makefile
new file mode 100644
index 0000000000..d1027d4509
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/Makefile
@@ -0,0 +1,5 @@
+startdb:
+ @harness/setup.sh start
+
+stopdb:
+ @harness/setup.sh stop
diff --git a/vendor/github.com/globalsign/mgo/README.md b/vendor/github.com/globalsign/mgo/README.md
new file mode 100644
index 0000000000..76fd05542d
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/README.md
@@ -0,0 +1,105 @@
+[](https://travis-ci.org/globalsign/mgo) [](https://godoc.org/github.com/globalsign/mgo)
+
+The MongoDB driver for Go
+-------------------------
+
+This fork has had a few improvements by ourselves as well as several PR's merged from the original mgo repo that are currently awaiting review.
+Changes are mostly geared towards performance improvements and bug fixes, though a few new features have been added.
+
+Further PR's (with tests) are welcome, but please maintain backwards compatibility.
+
+Detailed documentation of the API is available at
+[GoDoc](https://godoc.org/github.com/globalsign/mgo).
+
+A [sub-package](https://godoc.org/github.com/globalsign/mgo/bson) that implements the [BSON](http://bsonspec.org) specification is also included, and may be used independently of the driver.
+
+## Supported Versions
+
+`mgo` is known to work well on (and has integration tests against) MongoDB v3.0, 3.2, 3.4 and 3.6.
+
+MongoDB 4.0 is currently experimental - we would happily accept PRs to help improve support!
+
+## Changes
+* Fixes attempting to authenticate before every query ([details](https://github.com/go-mgo/mgo/issues/254))
+* Removes bulk update / delete batch size limitations ([details](https://github.com/go-mgo/mgo/issues/288))
+* Adds native support for `time.Duration` marshalling ([details](https://github.com/go-mgo/mgo/pull/373))
+* Reduce memory footprint / garbage collection pressure by reusing buffers ([details](https://github.com/go-mgo/mgo/pull/229), [more](https://github.com/globalsign/mgo/pull/56))
+* Support majority read concerns ([details](https://github.com/globalsign/mgo/pull/2))
+* Improved connection handling ([details](https://github.com/globalsign/mgo/pull/5))
+* Hides SASL warnings ([details](https://github.com/globalsign/mgo/pull/7))
+* Support for partial indexes ([details](https://github.com/domodwyer/mgo/commit/5efe8eccb028238d93c222828cae4806aeae9f51))
+* Fixes timezone handling ([details](https://github.com/go-mgo/mgo/pull/464))
+* Integration tests run against MongoDB 3.2 & 3.4 releases ([details](https://github.com/globalsign/mgo/pull/4), [more](https://github.com/globalsign/mgo/pull/24), [more](https://github.com/globalsign/mgo/pull/35))
+* Improved multi-document transaction performance ([details](https://github.com/globalsign/mgo/pull/10), [more](https://github.com/globalsign/mgo/pull/11), [more](https://github.com/globalsign/mgo/pull/16))
+* Fixes cursor timeouts ([details](https://jira.mongodb.org/browse/SERVER-24899))
+* Support index hints and timeouts for count queries ([details](https://github.com/globalsign/mgo/pull/17))
+* Don't panic when handling indexed `int64` fields ([details](https://github.com/go-mgo/mgo/issues/475))
+* Supports dropping all indexes on a collection ([details](https://github.com/globalsign/mgo/pull/25))
+* Annotates log entries/profiler output with optional appName on 3.4+ ([details](https://github.com/globalsign/mgo/pull/28))
+* Support for read-only [views](https://docs.mongodb.com/manual/core/views/) in 3.4+ ([details](https://github.com/globalsign/mgo/pull/33))
+* Support for [collations](https://docs.mongodb.com/manual/reference/collation/) in 3.4+ ([details](https://github.com/globalsign/mgo/pull/37), [more](https://github.com/globalsign/mgo/pull/166))
+* Provide BSON constants for convenience/sanity ([details](https://github.com/globalsign/mgo/pull/41))
+* Consistently unmarshal time.Time values as UTC ([details](https://github.com/globalsign/mgo/pull/42))
+* Enforces best practise coding guidelines ([details](https://github.com/globalsign/mgo/pull/44))
+* GetBSON correctly handles structs with both fields and pointers ([details](https://github.com/globalsign/mgo/pull/40))
+* Improved bson.Raw unmarshalling performance ([details](https://github.com/globalsign/mgo/pull/49))
+* Minimise socket connection timeouts due to excessive locking ([details](https://github.com/globalsign/mgo/pull/52))
+* Natively support X509 client authentication ([details](https://github.com/globalsign/mgo/pull/55))
+* Gracefully recover from a temporarily unreachable server ([details](https://github.com/globalsign/mgo/pull/69))
+* Use JSON tags when no explicit BSON are tags set ([details](https://github.com/globalsign/mgo/pull/91))
+* Support [$changeStream](https://docs.mongodb.com/manual/changeStreams/) tailing on 3.6+ ([details](https://github.com/globalsign/mgo/pull/97))
+* Fix deadlock in cluster synchronisation ([details](https://github.com/globalsign/mgo/issues/120))
+* Implement `maxIdleTimeout` for pooled connections ([details](https://github.com/globalsign/mgo/pull/116))
+* Connection pool waiting improvements ([details](https://github.com/globalsign/mgo/pull/115))
+* Fixes BSON encoding for `$in` and friends ([details](https://github.com/globalsign/mgo/pull/128))
+* Add BSON stream encoders ([details](https://github.com/globalsign/mgo/pull/127))
+* Add integer map key support in the BSON encoder ([details](https://github.com/globalsign/mgo/pull/140))
+* Support aggregation [collations](https://docs.mongodb.com/manual/reference/collation/) ([details](https://github.com/globalsign/mgo/pull/144))
+* Support encoding of inline struct references ([details](https://github.com/globalsign/mgo/pull/146))
+* Improved windows test harness ([details](https://github.com/globalsign/mgo/pull/158))
+* Improved type and nil handling in the BSON codec ([details](https://github.com/globalsign/mgo/pull/147/files), [more](https://github.com/globalsign/mgo/pull/181))
+* Separated network read/write timeouts ([details](https://github.com/globalsign/mgo/pull/161))
+* Expanded dial string configuration options ([details](https://github.com/globalsign/mgo/pull/162))
+* Implement MongoTimestamp ([details](https://github.com/globalsign/mgo/pull/171))
+* Support setting `writeConcern` for `findAndModify` operations ([details](https://github.com/globalsign/mgo/pull/185))
+* Add `ssl` to the dial string options ([details](https://github.com/globalsign/mgo/pull/184))
+
+
+---
+
+### Thanks to
+* @aksentyev
+* @bachue
+* @bozaro
+* @BenLubar
+* @carldunham
+* @carter2000
+* @cedric-cordenier
+* @cezarsa
+* @DaytonG
+* @ddspog
+* @drichelson
+* @dvic
+* @eaglerayp
+* @feliixx
+* @fmpwizard
+* @gazoon
+* @gedge
+* @gnawux
+* @idy
+* @jameinel
+* @jefferickson
+* @johnlawsharrison
+* @KJTsanaktsidis
+* @larrycinnabar
+* @mapete94
+* @maxnoel
+* @mcspring
+* @Mei-Zhao
+* @peterdeka
+* @Reenjii
+* @roobre
+* @smoya
+* @steve-gray
+* @tbruyelle
+* @wgallagher
diff --git a/vendor/github.com/globalsign/mgo/auth.go b/vendor/github.com/globalsign/mgo/auth.go
new file mode 100644
index 0000000000..75d2ebc365
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/auth.go
@@ -0,0 +1,467 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package mgo
+
+import (
+ "crypto/md5"
+ "crypto/sha1"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "sync"
+
+ "github.com/globalsign/mgo/bson"
+ "github.com/globalsign/mgo/internal/scram"
+)
+
+type authCmd struct {
+ Authenticate int
+
+ Nonce string
+ User string
+ Key string
+}
+
+type startSaslCmd struct {
+ StartSASL int `bson:"startSasl"`
+}
+
+type authResult struct {
+ ErrMsg string
+ Ok bool
+}
+
+type getNonceCmd struct {
+ GetNonce int
+}
+
+type getNonceResult struct {
+ Nonce string
+ Err string `bson:"$err"`
+ Code int
+}
+
+type logoutCmd struct {
+ Logout int
+}
+
+type saslCmd struct {
+ Start int `bson:"saslStart,omitempty"`
+ Continue int `bson:"saslContinue,omitempty"`
+ ConversationId int `bson:"conversationId,omitempty"`
+ Mechanism string `bson:"mechanism,omitempty"`
+ Payload []byte
+}
+
+type saslResult struct {
+ Ok bool `bson:"ok"`
+ NotOk bool `bson:"code"` // Server <= 2.3.2 returns ok=1 & code>0 on errors (WTF?)
+ Done bool
+
+ ConversationId int `bson:"conversationId"`
+ Payload []byte
+ ErrMsg string
+}
+
+type saslStepper interface {
+ Step(serverData []byte) (clientData []byte, done bool, err error)
+ Close()
+}
+
+func (socket *mongoSocket) getNonce() (nonce string, err error) {
+ socket.Lock()
+ for socket.cachedNonce == "" && socket.dead == nil {
+ debugf("Socket %p to %s: waiting for nonce", socket, socket.addr)
+ socket.gotNonce.Wait()
+ }
+ if socket.cachedNonce == "mongos" {
+ socket.Unlock()
+ return "", errors.New("Can't authenticate with mongos; see http://j.mp/mongos-auth")
+ }
+ debugf("Socket %p to %s: got nonce", socket, socket.addr)
+ nonce, err = socket.cachedNonce, socket.dead
+ socket.cachedNonce = ""
+ socket.Unlock()
+ if err != nil {
+ nonce = ""
+ }
+ return
+}
+
+func (socket *mongoSocket) resetNonce() {
+ debugf("Socket %p to %s: requesting a new nonce", socket, socket.addr)
+ op := &queryOp{}
+ op.query = &getNonceCmd{GetNonce: 1}
+ op.collection = "admin.$cmd"
+ op.limit = -1
+ op.replyFunc = func(err error, reply *replyOp, docNum int, docData []byte) {
+ if err != nil {
+ socket.kill(errors.New("getNonce: "+err.Error()), true)
+ return
+ }
+ result := &getNonceResult{}
+ err = bson.Unmarshal(docData, &result)
+ if err != nil {
+ socket.kill(errors.New("Failed to unmarshal nonce: "+err.Error()), true)
+ return
+ }
+ debugf("Socket %p to %s: nonce unmarshalled: %#v", socket, socket.addr, result)
+ if result.Code == 13390 {
+ // mongos doesn't yet support auth (see http://j.mp/mongos-auth)
+ result.Nonce = "mongos"
+ } else if result.Nonce == "" {
+ var msg string
+ if result.Err != "" {
+ msg = fmt.Sprintf("Got an empty nonce: %s (%d)", result.Err, result.Code)
+ } else {
+ msg = "Got an empty nonce"
+ }
+ socket.kill(errors.New(msg), true)
+ return
+ }
+ socket.Lock()
+ if socket.cachedNonce != "" {
+ socket.Unlock()
+ panic("resetNonce: nonce already cached")
+ }
+ socket.cachedNonce = result.Nonce
+ socket.gotNonce.Signal()
+ socket.Unlock()
+ }
+ err := socket.Query(op)
+ if err != nil {
+ socket.kill(errors.New("resetNonce: "+err.Error()), true)
+ }
+}
+
+func (socket *mongoSocket) Login(cred Credential) error {
+ socket.Lock()
+ if cred.Mechanism == "" && socket.serverInfo.MaxWireVersion >= 3 {
+ cred.Mechanism = "SCRAM-SHA-1"
+ }
+ for _, sockCred := range socket.creds {
+ if sockCred == cred {
+ debugf("Socket %p to %s: login: db=%q user=%q (already logged in)", socket, socket.addr, cred.Source, cred.Username)
+ socket.Unlock()
+ return nil
+ }
+ }
+ if socket.dropLogout(cred) {
+ debugf("Socket %p to %s: login: db=%q user=%q (cached)", socket, socket.addr, cred.Source, cred.Username)
+ socket.creds = append(socket.creds, cred)
+ socket.Unlock()
+ return nil
+ }
+ socket.Unlock()
+
+ debugf("Socket %p to %s: login: db=%q user=%q", socket, socket.addr, cred.Source, cred.Username)
+
+ var err error
+ switch cred.Mechanism {
+ case "", "MONGODB-CR", "MONGO-CR": // Name changed to MONGODB-CR in SERVER-8501.
+ err = socket.loginClassic(cred)
+ case "PLAIN":
+ err = socket.loginPlain(cred)
+ case "MONGODB-X509":
+ err = socket.loginX509(cred)
+ default:
+ // Try SASL for everything else, if it is available.
+ err = socket.loginSASL(cred)
+ }
+
+ if err != nil {
+ debugf("Socket %p to %s: login error: %s", socket, socket.addr, err)
+ } else {
+ debugf("Socket %p to %s: login successful", socket, socket.addr)
+ }
+ return err
+}
+
+func (socket *mongoSocket) loginClassic(cred Credential) error {
+ // Note that this only works properly because this function is
+ // synchronous, which means the nonce won't get reset while we're
+ // using it and any other login requests will block waiting for a
+ // new nonce provided in the defer call below.
+ nonce, err := socket.getNonce()
+ if err != nil {
+ return err
+ }
+ defer socket.resetNonce()
+
+ psum := md5.New()
+ psum.Write([]byte(cred.Username + ":mongo:" + cred.Password))
+
+ ksum := md5.New()
+ ksum.Write([]byte(nonce + cred.Username))
+ ksum.Write([]byte(hex.EncodeToString(psum.Sum(nil))))
+
+ key := hex.EncodeToString(ksum.Sum(nil))
+
+ cmd := authCmd{Authenticate: 1, User: cred.Username, Nonce: nonce, Key: key}
+ res := authResult{}
+ return socket.loginRun(cred.Source, &cmd, &res, func() error {
+ if !res.Ok {
+ return errors.New(res.ErrMsg)
+ }
+ socket.Lock()
+ socket.dropAuth(cred.Source)
+ socket.creds = append(socket.creds, cred)
+ socket.Unlock()
+ return nil
+ })
+}
+
+type authX509Cmd struct {
+ Authenticate int
+ User string
+ Mechanism string
+}
+
+func (socket *mongoSocket) loginX509(cred Credential) error {
+ cmd := authX509Cmd{Authenticate: 1, User: cred.Username, Mechanism: "MONGODB-X509"}
+ res := authResult{}
+ return socket.loginRun(cred.Source, &cmd, &res, func() error {
+ if !res.Ok {
+ return errors.New(res.ErrMsg)
+ }
+ socket.Lock()
+ socket.dropAuth(cred.Source)
+ socket.creds = append(socket.creds, cred)
+ socket.Unlock()
+ return nil
+ })
+}
+
+func (socket *mongoSocket) loginPlain(cred Credential) error {
+ cmd := saslCmd{Start: 1, Mechanism: "PLAIN", Payload: []byte("\x00" + cred.Username + "\x00" + cred.Password)}
+ res := authResult{}
+ return socket.loginRun(cred.Source, &cmd, &res, func() error {
+ if !res.Ok {
+ return errors.New(res.ErrMsg)
+ }
+ socket.Lock()
+ socket.dropAuth(cred.Source)
+ socket.creds = append(socket.creds, cred)
+ socket.Unlock()
+ return nil
+ })
+}
+
+func (socket *mongoSocket) loginSASL(cred Credential) error {
+ var sasl saslStepper
+ var err error
+ if cred.Mechanism == "SCRAM-SHA-1" {
+ // SCRAM is handled without external libraries.
+ sasl = saslNewScram(cred)
+ } else if len(cred.ServiceHost) > 0 {
+ sasl, err = saslNew(cred, cred.ServiceHost)
+ } else {
+ sasl, err = saslNew(cred, socket.Server().Addr)
+ }
+ if err != nil {
+ return err
+ }
+ defer sasl.Close()
+
+ // The goal of this logic is to carry a locked socket until the
+ // local SASL step confirms the auth is valid; the socket needs to be
+ // locked so that concurrent action doesn't leave the socket in an
+ // auth state that doesn't reflect the operations that took place.
+ // As a simple case, imagine inverting login=>logout to logout=>login.
+ //
+ // The logic below works because the lock func isn't called concurrently.
+ locked := false
+ lock := func(b bool) {
+ if locked != b {
+ locked = b
+ if b {
+ socket.Lock()
+ } else {
+ socket.Unlock()
+ }
+ }
+ }
+
+ lock(true)
+ defer lock(false)
+
+ start := 1
+ cmd := saslCmd{}
+ res := saslResult{}
+ for {
+ payload, done, err := sasl.Step(res.Payload)
+ if err != nil {
+ return err
+ }
+ if done && res.Done {
+ socket.dropAuth(cred.Source)
+ socket.creds = append(socket.creds, cred)
+ break
+ }
+ lock(false)
+
+ cmd = saslCmd{
+ Start: start,
+ Continue: 1 - start,
+ ConversationId: res.ConversationId,
+ Mechanism: cred.Mechanism,
+ Payload: payload,
+ }
+ start = 0
+ err = socket.loginRun(cred.Source, &cmd, &res, func() error {
+ // See the comment on lock for why this is necessary.
+ lock(true)
+ if !res.Ok || res.NotOk {
+ return fmt.Errorf("server returned error on SASL authentication step: %s", res.ErrMsg)
+ }
+ return nil
+ })
+ if err != nil {
+ return err
+ }
+ if done && res.Done {
+ socket.dropAuth(cred.Source)
+ socket.creds = append(socket.creds, cred)
+ break
+ }
+ }
+
+ return nil
+}
+
+func saslNewScram(cred Credential) *saslScram {
+ credsum := md5.New()
+ credsum.Write([]byte(cred.Username + ":mongo:" + cred.Password))
+ client := scram.NewClient(sha1.New, cred.Username, hex.EncodeToString(credsum.Sum(nil)))
+ return &saslScram{cred: cred, client: client}
+}
+
+type saslScram struct {
+ cred Credential
+ client *scram.Client
+}
+
+func (s *saslScram) Close() {}
+
+func (s *saslScram) Step(serverData []byte) (clientData []byte, done bool, err error) {
+ more := s.client.Step(serverData)
+ return s.client.Out(), !more, s.client.Err()
+}
+
+func (socket *mongoSocket) loginRun(db string, query, result interface{}, f func() error) error {
+ var mutex sync.Mutex
+ var replyErr error
+ mutex.Lock()
+
+ op := queryOp{}
+ op.query = query
+ op.collection = db + ".$cmd"
+ op.limit = -1
+ op.replyFunc = func(err error, reply *replyOp, docNum int, docData []byte) {
+ defer mutex.Unlock()
+
+ if err != nil {
+ replyErr = err
+ return
+ }
+
+ err = bson.Unmarshal(docData, result)
+ if err != nil {
+ replyErr = err
+ } else {
+ // Must handle this within the read loop for the socket, so
+ // that concurrent login requests are properly ordered.
+ replyErr = f()
+ }
+ }
+
+ err := socket.Query(&op)
+ if err != nil {
+ return err
+ }
+ mutex.Lock() // Wait.
+ return replyErr
+}
+
+func (socket *mongoSocket) Logout(db string) {
+ socket.Lock()
+ cred, found := socket.dropAuth(db)
+ if found {
+ debugf("Socket %p to %s: logout: db=%q (flagged)", socket, socket.addr, db)
+ socket.logout = append(socket.logout, cred)
+ }
+ socket.Unlock()
+}
+
+func (socket *mongoSocket) LogoutAll() {
+ socket.Lock()
+ if l := len(socket.creds); l > 0 {
+ debugf("Socket %p to %s: logout all (flagged %d)", socket, socket.addr, l)
+ socket.logout = append(socket.logout, socket.creds...)
+ socket.creds = socket.creds[0:0]
+ }
+ socket.Unlock()
+}
+
+func (socket *mongoSocket) flushLogout() (ops []interface{}) {
+ socket.Lock()
+ if l := len(socket.logout); l > 0 {
+ debugf("Socket %p to %s: logout all (flushing %d)", socket, socket.addr, l)
+ for i := 0; i != l; i++ {
+ op := queryOp{}
+ op.query = &logoutCmd{1}
+ op.collection = socket.logout[i].Source + ".$cmd"
+ op.limit = -1
+ ops = append(ops, &op)
+ }
+ socket.logout = socket.logout[0:0]
+ }
+ socket.Unlock()
+ return
+}
+
+func (socket *mongoSocket) dropAuth(db string) (cred Credential, found bool) {
+ for i, sockCred := range socket.creds {
+ if sockCred.Source == db {
+ copy(socket.creds[i:], socket.creds[i+1:])
+ socket.creds = socket.creds[:len(socket.creds)-1]
+ return sockCred, true
+ }
+ }
+ return cred, false
+}
+
+func (socket *mongoSocket) dropLogout(cred Credential) (found bool) {
+ for i, sockCred := range socket.logout {
+ if sockCred == cred {
+ copy(socket.logout[i:], socket.logout[i+1:])
+ socket.logout = socket.logout[:len(socket.logout)-1]
+ return true
+ }
+ }
+ return false
+}
diff --git a/vendor/github.com/globalsign/mgo/bson/LICENSE b/vendor/github.com/globalsign/mgo/bson/LICENSE
new file mode 100644
index 0000000000..890326017b
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/LICENSE
@@ -0,0 +1,25 @@
+BSON library for Go
+
+Copyright (c) 2010-2012 - Gustavo Niemeyer
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/globalsign/mgo/bson/README.md b/vendor/github.com/globalsign/mgo/bson/README.md
new file mode 100644
index 0000000000..5c5819e612
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/README.md
@@ -0,0 +1,12 @@
+[](https://godoc.org/github.com/globalsign/mgo/bson)
+
+An Implementation of BSON for Go
+--------------------------------
+
+Package bson is an implementation of the [BSON specification](http://bsonspec.org) for Go.
+
+While the BSON package implements the BSON spec as faithfully as possible, there
+is some MongoDB specific behaviour (such as map keys `$in`, `$all`, etc) in the
+`bson` package. The priority is for backwards compatibility for the `mgo`
+driver, though fixes for obviously buggy behaviour is welcome (and features, etc
+behind feature flags).
diff --git a/vendor/github.com/globalsign/mgo/bson/bson.go b/vendor/github.com/globalsign/mgo/bson/bson.go
new file mode 100644
index 0000000000..eb87ef6208
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/bson.go
@@ -0,0 +1,836 @@
+// BSON library for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Package bson is an implementation of the BSON specification for Go:
+//
+// http://bsonspec.org
+//
+// It was created as part of the mgo MongoDB driver for Go, but is standalone
+// and may be used on its own without the driver.
+package bson
+
+import (
+ "bytes"
+ "crypto/md5"
+ "crypto/rand"
+ "encoding/binary"
+ "encoding/hex"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "math"
+ "os"
+ "reflect"
+ "runtime"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "time"
+)
+
+//go:generate go run bson_corpus_spec_test_generator.go
+
+// --------------------------------------------------------------------------
+// The public API.
+
+// Element types constants from BSON specification.
+const (
+ ElementFloat64 byte = 0x01
+ ElementString byte = 0x02
+ ElementDocument byte = 0x03
+ ElementArray byte = 0x04
+ ElementBinary byte = 0x05
+ Element06 byte = 0x06
+ ElementObjectId byte = 0x07
+ ElementBool byte = 0x08
+ ElementDatetime byte = 0x09
+ ElementNil byte = 0x0A
+ ElementRegEx byte = 0x0B
+ ElementDBPointer byte = 0x0C
+ ElementJavaScriptWithoutScope byte = 0x0D
+ ElementSymbol byte = 0x0E
+ ElementJavaScriptWithScope byte = 0x0F
+ ElementInt32 byte = 0x10
+ ElementTimestamp byte = 0x11
+ ElementInt64 byte = 0x12
+ ElementDecimal128 byte = 0x13
+ ElementMinKey byte = 0xFF
+ ElementMaxKey byte = 0x7F
+
+ BinaryGeneric byte = 0x00
+ BinaryFunction byte = 0x01
+ BinaryBinaryOld byte = 0x02
+ BinaryUUIDOld byte = 0x03
+ BinaryUUID byte = 0x04
+ BinaryMD5 byte = 0x05
+ BinaryUserDefined byte = 0x80
+)
+
+// Getter interface: a value implementing the bson.Getter interface will have its GetBSON
+// method called when the given value has to be marshalled, and the result
+// of this method will be marshaled in place of the actual object.
+//
+// If GetBSON returns return a non-nil error, the marshalling procedure
+// will stop and error out with the provided value.
+type Getter interface {
+ GetBSON() (interface{}, error)
+}
+
+// Setter interface: a value implementing the bson.Setter interface will receive the BSON
+// value via the SetBSON method during unmarshaling, and the object
+// itself will not be changed as usual.
+//
+// If setting the value works, the method should return nil or alternatively
+// bson.ErrSetZero to set the respective field to its zero value (nil for
+// pointer types). If SetBSON returns a value of type bson.TypeError, the
+// BSON value will be omitted from a map or slice being decoded and the
+// unmarshalling will continue. If it returns any other non-nil error, the
+// unmarshalling procedure will stop and error out with the provided value.
+//
+// This interface is generally useful in pointer receivers, since the method
+// will want to change the receiver. A type field that implements the Setter
+// interface doesn't have to be a pointer, though.
+//
+// Unlike the usual behavior, unmarshalling onto a value that implements a
+// Setter interface will NOT reset the value to its zero state. This allows
+// the value to decide by itself how to be unmarshalled.
+//
+// For example:
+//
+// type MyString string
+//
+// func (s *MyString) SetBSON(raw bson.Raw) error {
+// return raw.Unmarshal(s)
+// }
+//
+type Setter interface {
+ SetBSON(raw Raw) error
+}
+
+// ErrSetZero may be returned from a SetBSON method to have the value set to
+// its respective zero value. When used in pointer values, this will set the
+// field to nil rather than to the pre-allocated value.
+var ErrSetZero = errors.New("set to zero")
+
+// M is a convenient alias for a map[string]interface{} map, useful for
+// dealing with BSON in a native way. For instance:
+//
+// bson.M{"a": 1, "b": true}
+//
+// There's no special handling for this type in addition to what's done anyway
+// for an equivalent map type. Elements in the map will be dumped in an
+// undefined ordered. See also the bson.D type for an ordered alternative.
+type M map[string]interface{}
+
+// D represents a BSON document containing ordered elements. For example:
+//
+// bson.D{{"a", 1}, {"b", true}}
+//
+// In some situations, such as when creating indexes for MongoDB, the order in
+// which the elements are defined is important. If the order is not important,
+// using a map is generally more comfortable. See bson.M and bson.RawD.
+type D []DocElem
+
+// DocElem is an element of the bson.D document representation.
+type DocElem struct {
+ Name string
+ Value interface{}
+}
+
+// Map returns a map out of the ordered element name/value pairs in d.
+func (d D) Map() (m M) {
+ m = make(M, len(d))
+ for _, item := range d {
+ m[item.Name] = item.Value
+ }
+ return m
+}
+
+// The Raw type represents raw unprocessed BSON documents and elements.
+// Kind is the kind of element as defined per the BSON specification, and
+// Data is the raw unprocessed data for the respective element.
+// Using this type it is possible to unmarshal or marshal values partially.
+//
+// Relevant documentation:
+//
+// http://bsonspec.org/#/specification
+//
+type Raw struct {
+ Kind byte
+ Data []byte
+}
+
+// RawD represents a BSON document containing raw unprocessed elements.
+// This low-level representation may be useful when lazily processing
+// documents of uncertain content, or when manipulating the raw content
+// documents in general.
+type RawD []RawDocElem
+
+// RawDocElem elements of RawD type.
+type RawDocElem struct {
+ Name string
+ Value Raw
+}
+
+// ObjectId is a unique ID identifying a BSON value. It must be exactly 12 bytes
+// long. MongoDB objects by default have such a property set in their "_id"
+// property.
+//
+// http://www.mongodb.org/display/DOCS/Object+Ids
+type ObjectId string
+
+// ObjectIdHex returns an ObjectId from the provided hex representation.
+// Calling this function with an invalid hex representation will
+// cause a runtime panic. See the IsObjectIdHex function.
+func ObjectIdHex(s string) ObjectId {
+ d, err := hex.DecodeString(s)
+ if err != nil || len(d) != 12 {
+ panic(fmt.Sprintf("invalid input to ObjectIdHex: %q", s))
+ }
+ return ObjectId(d)
+}
+
+// IsObjectIdHex returns whether s is a valid hex representation of
+// an ObjectId. See the ObjectIdHex function.
+func IsObjectIdHex(s string) bool {
+ if len(s) != 24 {
+ return false
+ }
+ _, err := hex.DecodeString(s)
+ return err == nil
+}
+
+// objectIdCounter is atomically incremented when generating a new ObjectId
+// using NewObjectId() function. It's used as a counter part of an id.
+var objectIdCounter = readRandomUint32()
+
+// readRandomUint32 returns a random objectIdCounter.
+func readRandomUint32() uint32 {
+ var b [4]byte
+ _, err := io.ReadFull(rand.Reader, b[:])
+ if err != nil {
+ panic(fmt.Errorf("cannot read random object id: %v", err))
+ }
+ return uint32((uint32(b[0]) << 0) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24))
+}
+
+// machineId stores machine id generated once and used in subsequent calls
+// to NewObjectId function.
+var machineId = readMachineId()
+var processId = os.Getpid()
+
+// readMachineId generates and returns a machine id.
+// If this function fails to get the hostname it will cause a runtime error.
+func readMachineId() []byte {
+ var sum [3]byte
+ id := sum[:]
+ hostname, err1 := os.Hostname()
+ if err1 != nil {
+ _, err2 := io.ReadFull(rand.Reader, id)
+ if err2 != nil {
+ panic(fmt.Errorf("cannot get hostname: %v; %v", err1, err2))
+ }
+ return id
+ }
+ hw := md5.New()
+ hw.Write([]byte(hostname))
+ copy(id, hw.Sum(nil))
+ return id
+}
+
+// NewObjectId returns a new unique ObjectId.
+func NewObjectId() ObjectId {
+ var b [12]byte
+ // Timestamp, 4 bytes, big endian
+ binary.BigEndian.PutUint32(b[:], uint32(time.Now().Unix()))
+ // Machine, first 3 bytes of md5(hostname)
+ b[4] = machineId[0]
+ b[5] = machineId[1]
+ b[6] = machineId[2]
+ // Pid, 2 bytes, specs don't specify endianness, but we use big endian.
+ b[7] = byte(processId >> 8)
+ b[8] = byte(processId)
+ // Increment, 3 bytes, big endian
+ i := atomic.AddUint32(&objectIdCounter, 1)
+ b[9] = byte(i >> 16)
+ b[10] = byte(i >> 8)
+ b[11] = byte(i)
+ return ObjectId(b[:])
+}
+
+// NewObjectIdWithTime returns a dummy ObjectId with the timestamp part filled
+// with the provided number of seconds from epoch UTC, and all other parts
+// filled with zeroes. It's not safe to insert a document with an id generated
+// by this method, it is useful only for queries to find documents with ids
+// generated before or after the specified timestamp.
+func NewObjectIdWithTime(t time.Time) ObjectId {
+ var b [12]byte
+ binary.BigEndian.PutUint32(b[:4], uint32(t.Unix()))
+ return ObjectId(string(b[:]))
+}
+
+// String returns a hex string representation of the id.
+// Example: ObjectIdHex("4d88e15b60f486e428412dc9").
+func (id ObjectId) String() string {
+ return fmt.Sprintf(`ObjectIdHex("%x")`, string(id))
+}
+
+// Hex returns a hex representation of the ObjectId.
+func (id ObjectId) Hex() string {
+ return hex.EncodeToString([]byte(id))
+}
+
+// MarshalJSON turns a bson.ObjectId into a json.Marshaller.
+func (id ObjectId) MarshalJSON() ([]byte, error) {
+ return []byte(fmt.Sprintf(`"%x"`, string(id))), nil
+}
+
+var nullBytes = []byte("null")
+
+// UnmarshalJSON turns *bson.ObjectId into a json.Unmarshaller.
+func (id *ObjectId) UnmarshalJSON(data []byte) error {
+ if len(data) > 0 && (data[0] == '{' || data[0] == 'O') {
+ var v struct {
+ Id json.RawMessage `json:"$oid"`
+ Func struct {
+ Id json.RawMessage
+ } `json:"$oidFunc"`
+ }
+ err := jdec(data, &v)
+ if err == nil {
+ if len(v.Id) > 0 {
+ data = []byte(v.Id)
+ } else {
+ data = []byte(v.Func.Id)
+ }
+ }
+ }
+ if len(data) == 2 && data[0] == '"' && data[1] == '"' || bytes.Equal(data, nullBytes) {
+ *id = ""
+ return nil
+ }
+ if len(data) != 26 || data[0] != '"' || data[25] != '"' {
+ return fmt.Errorf("invalid ObjectId in JSON: %s", string(data))
+ }
+ var buf [12]byte
+ _, err := hex.Decode(buf[:], data[1:25])
+ if err != nil {
+ return fmt.Errorf("invalid ObjectId in JSON: %s (%s)", string(data), err)
+ }
+ *id = ObjectId(string(buf[:]))
+ return nil
+}
+
+// MarshalText turns bson.ObjectId into an encoding.TextMarshaler.
+func (id ObjectId) MarshalText() ([]byte, error) {
+ return []byte(fmt.Sprintf("%x", string(id))), nil
+}
+
+// UnmarshalText turns *bson.ObjectId into an encoding.TextUnmarshaler.
+func (id *ObjectId) UnmarshalText(data []byte) error {
+ if len(data) == 1 && data[0] == ' ' || len(data) == 0 {
+ *id = ""
+ return nil
+ }
+ if len(data) != 24 {
+ return fmt.Errorf("invalid ObjectId: %s", data)
+ }
+ var buf [12]byte
+ _, err := hex.Decode(buf[:], data[:])
+ if err != nil {
+ return fmt.Errorf("invalid ObjectId: %s (%s)", data, err)
+ }
+ *id = ObjectId(string(buf[:]))
+ return nil
+}
+
+// Valid returns true if id is valid. A valid id must contain exactly 12 bytes.
+func (id ObjectId) Valid() bool {
+ return len(id) == 12
+}
+
+// byteSlice returns byte slice of id from start to end.
+// Calling this function with an invalid id will cause a runtime panic.
+func (id ObjectId) byteSlice(start, end int) []byte {
+ if len(id) != 12 {
+ panic(fmt.Sprintf("invalid ObjectId: %q", string(id)))
+ }
+ return []byte(string(id)[start:end])
+}
+
+// Time returns the timestamp part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Time() time.Time {
+ // First 4 bytes of ObjectId is 32-bit big-endian seconds from epoch.
+ secs := int64(binary.BigEndian.Uint32(id.byteSlice(0, 4)))
+ return time.Unix(secs, 0)
+}
+
+// Machine returns the 3-byte machine id part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Machine() []byte {
+ return id.byteSlice(4, 7)
+}
+
+// Pid returns the process id part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Pid() uint16 {
+ return binary.BigEndian.Uint16(id.byteSlice(7, 9))
+}
+
+// Counter returns the incrementing value part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Counter() int32 {
+ b := id.byteSlice(9, 12)
+ // Counter is stored as big-endian 3-byte value
+ return int32(uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]))
+}
+
+// The Symbol type is similar to a string and is used in languages with a
+// distinct symbol type.
+type Symbol string
+
+// Now returns the current time with millisecond precision. MongoDB stores
+// timestamps with the same precision, so a Time returned from this method
+// will not change after a roundtrip to the database. That's the only reason
+// why this function exists. Using the time.Now function also works fine
+// otherwise.
+func Now() time.Time {
+ return time.Unix(0, time.Now().UnixNano()/1e6*1e6)
+}
+
+// MongoTimestamp is a special internal type used by MongoDB that for some
+// strange reason has its own datatype defined in BSON.
+type MongoTimestamp int64
+
+// Time returns the time part of ts which is stored with second precision.
+func (ts MongoTimestamp) Time() time.Time {
+ return time.Unix(int64(uint64(ts)>>32), 0)
+}
+
+// Counter returns the counter part of ts.
+func (ts MongoTimestamp) Counter() uint32 {
+ return uint32(ts)
+}
+
+// NewMongoTimestamp creates a timestamp using the given
+// date `t` (with second precision) and counter `c` (unique for `t`).
+//
+// Returns an error if time `t` is not between 1970-01-01T00:00:00Z
+// and 2106-02-07T06:28:15Z (inclusive).
+//
+// Note that two MongoTimestamps should never have the same (time, counter) combination:
+// the caller must ensure the counter `c` is increased if creating multiple MongoTimestamp
+// values for the same time `t` (ignoring fractions of seconds).
+func NewMongoTimestamp(t time.Time, c uint32) (MongoTimestamp, error) {
+ u := t.Unix()
+ if u < 0 || u > math.MaxUint32 {
+ return -1, errors.New("invalid value for time")
+ }
+
+ i := int64(u<<32 | int64(c))
+
+ return MongoTimestamp(i), nil
+}
+
+type orderKey int64
+
+// MaxKey is a special value that compares higher than all other possible BSON
+// values in a MongoDB database.
+var MaxKey = orderKey(1<<63 - 1)
+
+// MinKey is a special value that compares lower than all other possible BSON
+// values in a MongoDB database.
+var MinKey = orderKey(-1 << 63)
+
+type undefined struct{}
+
+// Undefined represents the undefined BSON value.
+var Undefined undefined
+
+// Binary is a representation for non-standard binary values. Any kind should
+// work, but the following are known as of this writing:
+//
+// 0x00 - Generic. This is decoded as []byte(data), not Binary{0x00, data}.
+// 0x01 - Function (!?)
+// 0x02 - Obsolete generic.
+// 0x03 - UUID
+// 0x05 - MD5
+// 0x80 - User defined.
+//
+type Binary struct {
+ Kind byte
+ Data []byte
+}
+
+// RegEx represents a regular expression. The Options field may contain
+// individual characters defining the way in which the pattern should be
+// applied, and must be sorted. Valid options as of this writing are 'i' for
+// case insensitive matching, 'm' for multi-line matching, 'x' for verbose
+// mode, 'l' to make \w, \W, and similar be locale-dependent, 's' for dot-all
+// mode (a '.' matches everything), and 'u' to make \w, \W, and similar match
+// unicode. The value of the Options parameter is not verified before being
+// marshaled into the BSON format.
+type RegEx struct {
+ Pattern string
+ Options string
+}
+
+// JavaScript is a type that holds JavaScript code. If Scope is non-nil, it
+// will be marshaled as a mapping from identifiers to values that may be
+// used when evaluating the provided Code.
+type JavaScript struct {
+ Code string
+ Scope interface{}
+}
+
+// DBPointer refers to a document id in a namespace.
+//
+// This type is deprecated in the BSON specification and should not be used
+// except for backwards compatibility with ancient applications.
+type DBPointer struct {
+ Namespace string
+ Id ObjectId
+}
+
+const initialBufferSize = 64
+
+func handleErr(err *error) {
+ if r := recover(); r != nil {
+ if _, ok := r.(runtime.Error); ok {
+ panic(r)
+ } else if _, ok := r.(externalPanic); ok {
+ panic(r)
+ } else if s, ok := r.(string); ok {
+ *err = errors.New(s)
+ } else if e, ok := r.(error); ok {
+ *err = e
+ } else {
+ panic(r)
+ }
+ }
+}
+
+// Marshal serializes the in value, which may be a map or a struct value.
+// In the case of struct values, only exported fields will be serialized,
+// and the order of serialized fields will match that of the struct itself.
+// The lowercased field name is used as the key for each exported field,
+// but this behavior may be changed using the respective field tag.
+// The tag may also contain flags to tweak the marshalling behavior for
+// the field. The tag formats accepted are:
+//
+// "[][,[,]]"
+//
+// `(...) bson:"[][,[,]]" (...)`
+//
+// The following flags are currently supported:
+//
+// omitempty Only include the field if it's not set to the zero
+// value for the type or to empty slices or maps.
+//
+// minsize Marshal an int64 value as an int32, if that's feasible
+// while preserving the numeric value.
+//
+// inline Inline the field, which must be a struct or a map,
+// causing all of its fields or keys to be processed as if
+// they were part of the outer struct. For maps, keys must
+// not conflict with the bson keys of other struct fields.
+//
+// Some examples:
+//
+// type T struct {
+// A bool
+// B int "myb"
+// C string "myc,omitempty"
+// D string `bson:",omitempty" json:"jsonkey"`
+// E int64 ",minsize"
+// F int64 "myf,omitempty,minsize"
+// }
+//
+func Marshal(in interface{}) (out []byte, err error) {
+ return MarshalBuffer(in, make([]byte, 0, initialBufferSize))
+}
+
+// MarshalBuffer behaves the same way as Marshal, except that instead of
+// allocating a new byte slice it tries to use the received byte slice and
+// only allocates more memory if necessary to fit the marshaled value.
+func MarshalBuffer(in interface{}, buf []byte) (out []byte, err error) {
+ defer handleErr(&err)
+ e := &encoder{buf}
+ e.addDoc(reflect.ValueOf(in))
+ return e.out, nil
+}
+
+// Unmarshal deserializes data from in into the out value. The out value
+// must be a map, a pointer to a struct, or a pointer to a bson.D value.
+// In the case of struct values, only exported fields will be deserialized.
+// The lowercased field name is used as the key for each exported field,
+// but this behavior may be changed using the respective field tag.
+// The tag may also contain flags to tweak the marshalling behavior for
+// the field. The tag formats accepted are:
+//
+// "[][,[,]]"
+//
+// `(...) bson:"[][,[,]]" (...)`
+//
+// The following flags are currently supported during unmarshal (see the
+// Marshal method for other flags):
+//
+// inline Inline the field, which must be a struct or a map.
+// Inlined structs are handled as if its fields were part
+// of the outer struct. An inlined map causes keys that do
+// not match any other struct field to be inserted in the
+// map rather than being discarded as usual.
+//
+// The target field or element types of out may not necessarily match
+// the BSON values of the provided data. The following conversions are
+// made automatically:
+//
+// - Numeric types are converted if at least the integer part of the
+// value would be preserved correctly
+// - Bools are converted to numeric types as 1 or 0
+// - Numeric types are converted to bools as true if not 0 or false otherwise
+// - Binary and string BSON data is converted to a string, array or byte slice
+//
+// If the value would not fit the type and cannot be converted, it's
+// silently skipped.
+//
+// Pointer values are initialized when necessary.
+func Unmarshal(in []byte, out interface{}) (err error) {
+ if raw, ok := out.(*Raw); ok {
+ raw.Kind = 3
+ raw.Data = in
+ return nil
+ }
+ defer handleErr(&err)
+ v := reflect.ValueOf(out)
+ switch v.Kind() {
+ case reflect.Ptr:
+ fallthrough
+ case reflect.Map:
+ d := newDecoder(in)
+ d.readDocTo(v)
+ if d.i < len(d.in) {
+ return errors.New("document is corrupted")
+ }
+ case reflect.Struct:
+ return errors.New("unmarshal can't deal with struct values. Use a pointer")
+ default:
+ return errors.New("unmarshal needs a map or a pointer to a struct")
+ }
+ return nil
+}
+
+// Unmarshal deserializes raw into the out value. If the out value type
+// is not compatible with raw, a *bson.TypeError is returned.
+//
+// See the Unmarshal function documentation for more details on the
+// unmarshalling process.
+func (raw Raw) Unmarshal(out interface{}) (err error) {
+ defer handleErr(&err)
+ v := reflect.ValueOf(out)
+ switch v.Kind() {
+ case reflect.Ptr:
+ v = v.Elem()
+ fallthrough
+ case reflect.Map:
+ d := newDecoder(raw.Data)
+ good := d.readElemTo(v, raw.Kind)
+ if !good {
+ return &TypeError{v.Type(), raw.Kind}
+ }
+ case reflect.Struct:
+ return errors.New("raw Unmarshal can't deal with struct values. Use a pointer")
+ default:
+ return errors.New("raw Unmarshal needs a map or a valid pointer")
+ }
+ return nil
+}
+
+// TypeError store details for type error occuring
+// during unmarshaling
+type TypeError struct {
+ Type reflect.Type
+ Kind byte
+}
+
+func (e *TypeError) Error() string {
+ return fmt.Sprintf("BSON kind 0x%02x isn't compatible with type %s", e.Kind, e.Type.String())
+}
+
+// --------------------------------------------------------------------------
+// Maintain a mapping of keys to structure field indexes
+
+type structInfo struct {
+ FieldsMap map[string]fieldInfo
+ FieldsList []fieldInfo
+ InlineMap int
+ Zero reflect.Value
+}
+
+type fieldInfo struct {
+ Key string
+ Num int
+ OmitEmpty bool
+ MinSize bool
+ Inline []int
+}
+
+var structMap = make(map[reflect.Type]*structInfo)
+var structMapMutex sync.RWMutex
+
+type externalPanic string
+
+func (e externalPanic) String() string {
+ return string(e)
+}
+
+func getStructInfo(st reflect.Type) (*structInfo, error) {
+ structMapMutex.RLock()
+ sinfo, found := structMap[st]
+ structMapMutex.RUnlock()
+ if found {
+ return sinfo, nil
+ }
+ n := st.NumField()
+ fieldsMap := make(map[string]fieldInfo)
+ fieldsList := make([]fieldInfo, 0, n)
+ inlineMap := -1
+ for i := 0; i != n; i++ {
+ field := st.Field(i)
+ if field.PkgPath != "" && !field.Anonymous {
+ continue // Private field
+ }
+
+ info := fieldInfo{Num: i}
+
+ tag := field.Tag.Get("bson")
+
+ // Fall-back to JSON struct tag, if feature flag is set.
+ if tag == "" && useJSONTagFallback {
+ tag = field.Tag.Get("json")
+ }
+
+ // If there's no bson/json tag available.
+ if tag == "" {
+ // If there's no tag, and also no tag: value splits (i.e. no colon)
+ // then assume the entire tag is the value
+ if strings.Index(string(field.Tag), ":") < 0 {
+ tag = string(field.Tag)
+ }
+ }
+
+ if tag == "-" {
+ continue
+ }
+
+ inline := false
+ fields := strings.Split(tag, ",")
+ if len(fields) > 1 {
+ for _, flag := range fields[1:] {
+ switch flag {
+ case "omitempty":
+ info.OmitEmpty = true
+ case "minsize":
+ info.MinSize = true
+ case "inline":
+ inline = true
+ default:
+ msg := fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st)
+ panic(externalPanic(msg))
+ }
+ }
+ tag = fields[0]
+ }
+
+ if inline {
+ switch field.Type.Kind() {
+ case reflect.Map:
+ if inlineMap >= 0 {
+ return nil, errors.New("Multiple ,inline maps in struct " + st.String())
+ }
+ if field.Type.Key() != reflect.TypeOf("") {
+ return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
+ }
+ inlineMap = info.Num
+ case reflect.Ptr:
+ // allow only pointer to struct
+ if kind := field.Type.Elem().Kind(); kind != reflect.Struct {
+ return nil, errors.New("Option ,inline allows a pointer only to a struct, was given pointer to " + kind.String())
+ }
+
+ field.Type = field.Type.Elem()
+ fallthrough
+ case reflect.Struct:
+ sinfo, err := getStructInfo(field.Type)
+ if err != nil {
+ return nil, err
+ }
+ for _, finfo := range sinfo.FieldsList {
+ if _, found := fieldsMap[finfo.Key]; found {
+ msg := "Duplicated key '" + finfo.Key + "' in struct " + st.String()
+ return nil, errors.New(msg)
+ }
+ if finfo.Inline == nil {
+ finfo.Inline = []int{i, finfo.Num}
+ } else {
+ finfo.Inline = append([]int{i}, finfo.Inline...)
+ }
+ fieldsMap[finfo.Key] = finfo
+ fieldsList = append(fieldsList, finfo)
+ }
+ default:
+ panic("Option ,inline needs a struct value or a pointer to a struct or map field")
+ }
+ continue
+ }
+
+ if tag != "" {
+ info.Key = tag
+ } else {
+ info.Key = strings.ToLower(field.Name)
+ }
+
+ if _, found = fieldsMap[info.Key]; found {
+ msg := "Duplicated key '" + info.Key + "' in struct " + st.String()
+ return nil, errors.New(msg)
+ }
+
+ fieldsList = append(fieldsList, info)
+ fieldsMap[info.Key] = info
+ }
+ sinfo = &structInfo{
+ fieldsMap,
+ fieldsList,
+ inlineMap,
+ reflect.New(st).Elem(),
+ }
+ structMapMutex.Lock()
+ structMap[st] = sinfo
+ structMapMutex.Unlock()
+ return sinfo, nil
+}
diff --git a/vendor/github.com/globalsign/mgo/bson/bson_corpus_spec_test_generator.go b/vendor/github.com/globalsign/mgo/bson/bson_corpus_spec_test_generator.go
new file mode 100644
index 0000000000..3525a004b6
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/bson_corpus_spec_test_generator.go
@@ -0,0 +1,294 @@
+// +build ignore
+
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "go/format"
+ "html/template"
+ "io/ioutil"
+ "log"
+ "path/filepath"
+ "strings"
+
+ "github.com/globalsign/mgo/internal/json"
+)
+
+func main() {
+ log.SetFlags(0)
+ log.SetPrefix(name + ": ")
+
+ var g Generator
+
+ fmt.Fprintf(&g, "// Code generated by \"%s.go\"; DO NOT EDIT\n\n", name)
+
+ src := g.generate()
+
+ err := ioutil.WriteFile(fmt.Sprintf("%s.go", strings.TrimSuffix(name, "_generator")), src, 0644)
+ if err != nil {
+ log.Fatalf("writing output: %s", err)
+ }
+}
+
+// Generator holds the state of the analysis. Primarily used to buffer
+// the output for format.Source.
+type Generator struct {
+ bytes.Buffer // Accumulated output.
+}
+
+// format returns the gofmt-ed contents of the Generator's buffer.
+func (g *Generator) format() []byte {
+ src, err := format.Source(g.Bytes())
+ if err != nil {
+ // Should never happen, but can arise when developing this code.
+ // The user can compile the output to see the error.
+ log.Printf("warning: internal error: invalid Go generated: %s", err)
+ log.Printf("warning: compile the package to analyze the error")
+ return g.Bytes()
+ }
+ return src
+}
+
+// EVERYTHING ABOVE IS CONSTANT BETWEEN THE GENERATORS
+
+const name = "bson_corpus_spec_test_generator"
+
+func (g *Generator) generate() []byte {
+
+ testFiles, err := filepath.Glob("./specdata/specifications/source/bson-corpus/tests/*.json")
+ if err != nil {
+ log.Fatalf("error reading bson-corpus files: %s", err)
+ }
+
+ tests, err := g.loadTests(testFiles)
+ if err != nil {
+ log.Fatalf("error loading tests: %s", err)
+ }
+
+ tmpl, err := g.getTemplate()
+ if err != nil {
+ log.Fatalf("error loading template: %s", err)
+ }
+
+ tmpl.Execute(&g.Buffer, tests)
+
+ return g.format()
+}
+
+func (g *Generator) loadTests(filenames []string) ([]*testDef, error) {
+ var tests []*testDef
+ for _, filename := range filenames {
+ test, err := g.loadTest(filename)
+ if err != nil {
+ return nil, err
+ }
+
+ tests = append(tests, test)
+ }
+
+ return tests, nil
+}
+
+func (g *Generator) loadTest(filename string) (*testDef, error) {
+ content, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+
+ var testDef testDef
+ err = json.Unmarshal(content, &testDef)
+ if err != nil {
+ return nil, err
+ }
+
+ names := make(map[string]struct{})
+
+ for i := len(testDef.Valid) - 1; i >= 0; i-- {
+ if testDef.BsonType == "0x05" && testDef.Valid[i].Description == "subtype 0x02" {
+ testDef.Valid = append(testDef.Valid[:i], testDef.Valid[i+1:]...)
+ continue
+ }
+
+ name := cleanupFuncName(testDef.Description + "_" + testDef.Valid[i].Description)
+ nameIdx := name
+ j := 1
+ for {
+ if _, ok := names[nameIdx]; !ok {
+ break
+ }
+
+ nameIdx = fmt.Sprintf("%s_%d", name, j)
+ }
+
+ names[nameIdx] = struct{}{}
+
+ testDef.Valid[i].TestDef = &testDef
+ testDef.Valid[i].Name = nameIdx
+ testDef.Valid[i].StructTest = testDef.TestKey != "" &&
+ (testDef.BsonType != "0x05" || strings.Contains(testDef.Valid[i].Description, "0x00")) &&
+ !testDef.Deprecated
+ }
+
+ for i := len(testDef.DecodeErrors) - 1; i >= 0; i-- {
+ if strings.Contains(testDef.DecodeErrors[i].Description, "UTF-8") {
+ testDef.DecodeErrors = append(testDef.DecodeErrors[:i], testDef.DecodeErrors[i+1:]...)
+ continue
+ }
+
+ name := cleanupFuncName(testDef.Description + "_" + testDef.DecodeErrors[i].Description)
+ nameIdx := name
+ j := 1
+ for {
+ if _, ok := names[nameIdx]; !ok {
+ break
+ }
+
+ nameIdx = fmt.Sprintf("%s_%d", name, j)
+ }
+ names[nameIdx] = struct{}{}
+
+ testDef.DecodeErrors[i].Name = nameIdx
+ }
+
+ return &testDef, nil
+}
+
+func (g *Generator) getTemplate() (*template.Template, error) {
+ content := `package bson_test
+
+import (
+ "encoding/hex"
+ "time"
+
+ . "gopkg.in/check.v1"
+ "github.com/globalsign/mgo/bson"
+)
+
+func testValid(c *C, in []byte, expected []byte, result interface{}) {
+ err := bson.Unmarshal(in, result)
+ c.Assert(err, IsNil)
+
+ out, err := bson.Marshal(result)
+ c.Assert(err, IsNil)
+
+ c.Assert(string(expected), Equals, string(out), Commentf("roundtrip failed for %T, expected '%x' but got '%x'", result, expected, out))
+}
+
+func testDecodeSkip(c *C, in []byte) {
+ err := bson.Unmarshal(in, &struct{}{})
+ c.Assert(err, IsNil)
+}
+
+func testDecodeError(c *C, in []byte, result interface{}) {
+ err := bson.Unmarshal(in, result)
+ c.Assert(err, Not(IsNil))
+}
+
+{{range .}}
+{{range .Valid}}
+func (s *S) Test{{.Name}}(c *C) {
+ b, err := hex.DecodeString("{{.Bson}}")
+ c.Assert(err, IsNil)
+
+ {{if .CanonicalBson}}
+ cb, err := hex.DecodeString("{{.CanonicalBson}}")
+ c.Assert(err, IsNil)
+ {{else}}
+ cb := b
+ {{end}}
+
+ var resultD bson.D
+ testValid(c, b, cb, &resultD)
+ {{if .StructTest}}var resultS struct {
+ Element {{.TestDef.GoType}} ` + "`bson:\"{{.TestDef.TestKey}}\"`" + `
+ }
+ testValid(c, b, cb, &resultS){{end}}
+
+ testDecodeSkip(c, b)
+}
+{{end}}
+
+{{range .DecodeErrors}}
+func (s *S) Test{{.Name}}(c *C) {
+ b, err := hex.DecodeString("{{.Bson}}")
+ c.Assert(err, IsNil)
+
+ var resultD bson.D
+ testDecodeError(c, b, &resultD)
+}
+{{end}}
+{{end}}
+`
+ tmpl, err := template.New("").Parse(content)
+ if err != nil {
+ return nil, err
+ }
+ return tmpl, nil
+}
+
+func cleanupFuncName(name string) string {
+ return strings.Map(func(r rune) rune {
+ if (r >= 48 && r <= 57) || (r >= 65 && r <= 90) || (r >= 97 && r <= 122) {
+ return r
+ }
+ return '_'
+ }, name)
+}
+
+type testDef struct {
+ Description string `json:"description"`
+ BsonType string `json:"bson_type"`
+ TestKey string `json:"test_key"`
+ Valid []*valid `json:"valid"`
+ DecodeErrors []*decodeError `json:"decodeErrors"`
+ Deprecated bool `json:"deprecated"`
+}
+
+func (t *testDef) GoType() string {
+ switch t.BsonType {
+ case "0x01":
+ return "float64"
+ case "0x02":
+ return "string"
+ case "0x03":
+ return "bson.D"
+ case "0x04":
+ return "[]interface{}"
+ case "0x05":
+ return "[]byte"
+ case "0x07":
+ return "bson.ObjectId"
+ case "0x08":
+ return "bool"
+ case "0x09":
+ return "time.Time"
+ case "0x0E":
+ return "string"
+ case "0x10":
+ return "int32"
+ case "0x12":
+ return "int64"
+ case "0x13":
+ return "bson.Decimal"
+ default:
+ return "interface{}"
+ }
+}
+
+type valid struct {
+ Description string `json:"description"`
+ Bson string `json:"bson"`
+ CanonicalBson string `json:"canonical_bson"`
+
+ Name string
+ StructTest bool
+ TestDef *testDef
+}
+
+type decodeError struct {
+ Description string `json:"description"`
+ Bson string `json:"bson"`
+
+ Name string
+}
diff --git a/vendor/github.com/globalsign/mgo/bson/compatibility.go b/vendor/github.com/globalsign/mgo/bson/compatibility.go
new file mode 100644
index 0000000000..66efd465fa
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/compatibility.go
@@ -0,0 +1,29 @@
+package bson
+
+// Current state of the JSON tag fallback option.
+var useJSONTagFallback = false
+var useRespectNilValues = false
+
+// SetJSONTagFallback enables or disables the JSON-tag fallback for structure tagging. When this is enabled, structures
+// without BSON tags on a field will fall-back to using the JSON tag (if present).
+func SetJSONTagFallback(state bool) {
+ useJSONTagFallback = state
+}
+
+// JSONTagFallbackState returns the current status of the JSON tag fallback compatability option. See SetJSONTagFallback
+// for more information.
+func JSONTagFallbackState() bool {
+ return useJSONTagFallback
+}
+
+// SetRespectNilValues enables or disables serializing nil slices or maps to `null` values.
+// In other words it enables `encoding/json` compatible behaviour.
+func SetRespectNilValues(state bool) {
+ useRespectNilValues = state
+}
+
+// RespectNilValuesState returns the current status of the JSON nil slices and maps fallback compatibility option.
+// See SetRespectNilValues for more information.
+func RespectNilValuesState() bool {
+ return useRespectNilValues
+}
diff --git a/vendor/github.com/globalsign/mgo/bson/decimal.go b/vendor/github.com/globalsign/mgo/bson/decimal.go
new file mode 100644
index 0000000000..672ba18259
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/decimal.go
@@ -0,0 +1,312 @@
+// BSON library for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package bson
+
+import (
+ "fmt"
+ "strconv"
+ "strings"
+)
+
+// Decimal128 holds decimal128 BSON values.
+type Decimal128 struct {
+ h, l uint64
+}
+
+func (d Decimal128) String() string {
+ var pos int // positive sign
+ var e int // exponent
+ var h, l uint64 // significand high/low
+
+ if d.h>>63&1 == 0 {
+ pos = 1
+ }
+
+ switch d.h >> 58 & (1<<5 - 1) {
+ case 0x1F:
+ return "NaN"
+ case 0x1E:
+ return "-Inf"[pos:]
+ }
+
+ l = d.l
+ if d.h>>61&3 == 3 {
+ // Bits: 1*sign 2*ignored 14*exponent 111*significand.
+ // Implicit 0b100 prefix in significand.
+ e = int(d.h>>47&(1<<14-1)) - 6176
+ //h = 4<<47 | d.h&(1<<47-1)
+ // Spec says all of these values are out of range.
+ h, l = 0, 0
+ } else {
+ // Bits: 1*sign 14*exponent 113*significand
+ e = int(d.h>>49&(1<<14-1)) - 6176
+ h = d.h & (1<<49 - 1)
+ }
+
+ // Would be handled by the logic below, but that's trivial and common.
+ if h == 0 && l == 0 && e == 0 {
+ return "-0"[pos:]
+ }
+
+ var repr [48]byte // Loop 5 times over 9 digits plus dot, negative sign, and leading zero.
+ var last = len(repr)
+ var i = len(repr)
+ var dot = len(repr) + e
+ var rem uint32
+Loop:
+ for d9 := 0; d9 < 5; d9++ {
+ h, l, rem = divmod(h, l, 1e9)
+ for d1 := 0; d1 < 9; d1++ {
+ // Handle "-0.0", "0.00123400", "-1.00E-6", "1.050E+3", etc.
+ if i < len(repr) && (dot == i || l == 0 && h == 0 && rem > 0 && rem < 10 && (dot < i-6 || e > 0)) {
+ e += len(repr) - i
+ i--
+ repr[i] = '.'
+ last = i - 1
+ dot = len(repr) // Unmark.
+ }
+ c := '0' + byte(rem%10)
+ rem /= 10
+ i--
+ repr[i] = c
+ // Handle "0E+3", "1E+3", etc.
+ if l == 0 && h == 0 && rem == 0 && i == len(repr)-1 && (dot < i-5 || e > 0) {
+ last = i
+ break Loop
+ }
+ if c != '0' {
+ last = i
+ }
+ // Break early. Works without it, but why.
+ if dot > i && l == 0 && h == 0 && rem == 0 {
+ break Loop
+ }
+ }
+ }
+ repr[last-1] = '-'
+ last--
+
+ if e > 0 {
+ return string(repr[last+pos:]) + "E+" + strconv.Itoa(e)
+ }
+ if e < 0 {
+ return string(repr[last+pos:]) + "E" + strconv.Itoa(e)
+ }
+ return string(repr[last+pos:])
+}
+
+func divmod(h, l uint64, div uint32) (qh, ql uint64, rem uint32) {
+ div64 := uint64(div)
+ a := h >> 32
+ aq := a / div64
+ ar := a % div64
+ b := ar<<32 + h&(1<<32-1)
+ bq := b / div64
+ br := b % div64
+ c := br<<32 + l>>32
+ cq := c / div64
+ cr := c % div64
+ d := cr<<32 + l&(1<<32-1)
+ dq := d / div64
+ dr := d % div64
+ return (aq<<32 | bq), (cq<<32 | dq), uint32(dr)
+}
+
+var dNaN = Decimal128{0x1F << 58, 0}
+var dPosInf = Decimal128{0x1E << 58, 0}
+var dNegInf = Decimal128{0x3E << 58, 0}
+
+func dErr(s string) (Decimal128, error) {
+ return dNaN, fmt.Errorf("cannot parse %q as a decimal128", s)
+}
+
+// ParseDecimal128 parse a string and return the corresponding value as
+// a decimal128
+func ParseDecimal128(s string) (Decimal128, error) {
+ orig := s
+ if s == "" {
+ return dErr(orig)
+ }
+ neg := s[0] == '-'
+ if neg || s[0] == '+' {
+ s = s[1:]
+ }
+
+ if (len(s) == 3 || len(s) == 8) && (s[0] == 'N' || s[0] == 'n' || s[0] == 'I' || s[0] == 'i') {
+ if s == "NaN" || s == "nan" || strings.EqualFold(s, "nan") {
+ return dNaN, nil
+ }
+ if s == "Inf" || s == "inf" || strings.EqualFold(s, "inf") || strings.EqualFold(s, "infinity") {
+ if neg {
+ return dNegInf, nil
+ }
+ return dPosInf, nil
+ }
+ return dErr(orig)
+ }
+
+ var h, l uint64
+ var e int
+
+ var add, ovr uint32
+ var mul uint32 = 1
+ var dot = -1
+ var digits = 0
+ var i = 0
+ for i < len(s) {
+ c := s[i]
+ if mul == 1e9 {
+ h, l, ovr = muladd(h, l, mul, add)
+ mul, add = 1, 0
+ if ovr > 0 || h&((1<<15-1)<<49) > 0 {
+ return dErr(orig)
+ }
+ }
+ if c >= '0' && c <= '9' {
+ i++
+ if c > '0' || digits > 0 {
+ digits++
+ }
+ if digits > 34 {
+ if c == '0' {
+ // Exact rounding.
+ e++
+ continue
+ }
+ return dErr(orig)
+ }
+ mul *= 10
+ add *= 10
+ add += uint32(c - '0')
+ continue
+ }
+ if c == '.' {
+ i++
+ if dot >= 0 || i == 1 && len(s) == 1 {
+ return dErr(orig)
+ }
+ if i == len(s) {
+ break
+ }
+ if s[i] < '0' || s[i] > '9' || e > 0 {
+ return dErr(orig)
+ }
+ dot = i
+ continue
+ }
+ break
+ }
+ if i == 0 {
+ return dErr(orig)
+ }
+ if mul > 1 {
+ h, l, ovr = muladd(h, l, mul, add)
+ if ovr > 0 || h&((1<<15-1)<<49) > 0 {
+ return dErr(orig)
+ }
+ }
+ if dot >= 0 {
+ e += dot - i
+ }
+ if i+1 < len(s) && (s[i] == 'E' || s[i] == 'e') {
+ i++
+ eneg := s[i] == '-'
+ if eneg || s[i] == '+' {
+ i++
+ if i == len(s) {
+ return dErr(orig)
+ }
+ }
+ n := 0
+ for i < len(s) && n < 1e4 {
+ c := s[i]
+ i++
+ if c < '0' || c > '9' {
+ return dErr(orig)
+ }
+ n *= 10
+ n += int(c - '0')
+ }
+ if eneg {
+ n = -n
+ }
+ e += n
+ for e < -6176 {
+ // Subnormal.
+ var div uint32 = 1
+ for div < 1e9 && e < -6176 {
+ div *= 10
+ e++
+ }
+ var rem uint32
+ h, l, rem = divmod(h, l, div)
+ if rem > 0 {
+ return dErr(orig)
+ }
+ }
+ for e > 6111 {
+ // Clamped.
+ var mul uint32 = 1
+ for mul < 1e9 && e > 6111 {
+ mul *= 10
+ e--
+ }
+ h, l, ovr = muladd(h, l, mul, 0)
+ if ovr > 0 || h&((1<<15-1)<<49) > 0 {
+ return dErr(orig)
+ }
+ }
+ if e < -6176 || e > 6111 {
+ return dErr(orig)
+ }
+ }
+
+ if i < len(s) {
+ return dErr(orig)
+ }
+
+ h |= uint64(e+6176) & uint64(1<<14-1) << 49
+ if neg {
+ h |= 1 << 63
+ }
+ return Decimal128{h, l}, nil
+}
+
+func muladd(h, l uint64, mul uint32, add uint32) (resh, resl uint64, overflow uint32) {
+ mul64 := uint64(mul)
+ a := mul64 * (l & (1<<32 - 1))
+ b := a>>32 + mul64*(l>>32)
+ c := b>>32 + mul64*(h&(1<<32-1))
+ d := c>>32 + mul64*(h>>32)
+
+ a = a&(1<<32-1) + uint64(add)
+ b = b&(1<<32-1) + a>>32
+ c = c&(1<<32-1) + b>>32
+ d = d&(1<<32-1) + c>>32
+
+ return (d<<32 | c&(1<<32-1)), (b<<32 | a&(1<<32-1)), uint32(d >> 32)
+}
diff --git a/vendor/github.com/globalsign/mgo/bson/decode.go b/vendor/github.com/globalsign/mgo/bson/decode.go
new file mode 100644
index 0000000000..658856add0
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/decode.go
@@ -0,0 +1,1055 @@
+// BSON library for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// gobson - BSON library for Go.
+
+package bson
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "math"
+ "net/url"
+ "reflect"
+ "strconv"
+ "sync"
+ "time"
+)
+
+type decoder struct {
+ in []byte
+ i int
+ docType reflect.Type
+}
+
+var typeM = reflect.TypeOf(M{})
+
+func newDecoder(in []byte) *decoder {
+ return &decoder{in, 0, typeM}
+}
+
+// --------------------------------------------------------------------------
+// Some helper functions.
+
+func corrupted() {
+ panic("Document is corrupted")
+}
+
+// --------------------------------------------------------------------------
+// Unmarshaling of documents.
+
+const (
+ setterUnknown = iota
+ setterNone
+ setterType
+ setterAddr
+)
+
+var setterStyles map[reflect.Type]int
+var setterIface reflect.Type
+var setterMutex sync.RWMutex
+
+func init() {
+ var iface Setter
+ setterIface = reflect.TypeOf(&iface).Elem()
+ setterStyles = make(map[reflect.Type]int)
+}
+
+func setterStyle(outt reflect.Type) int {
+ setterMutex.RLock()
+ style := setterStyles[outt]
+ setterMutex.RUnlock()
+ if style != setterUnknown {
+ return style
+ }
+
+ setterMutex.Lock()
+ defer setterMutex.Unlock()
+ if outt.Implements(setterIface) {
+ style = setterType
+ } else if reflect.PtrTo(outt).Implements(setterIface) {
+ style = setterAddr
+ } else {
+ style = setterNone
+ }
+ setterStyles[outt] = style
+ return style
+}
+
+func getSetter(outt reflect.Type, out reflect.Value) Setter {
+ style := setterStyle(outt)
+ if style == setterNone {
+ return nil
+ }
+ if style == setterAddr {
+ if !out.CanAddr() {
+ return nil
+ }
+ out = out.Addr()
+ } else if outt.Kind() == reflect.Ptr && out.IsNil() {
+ out.Set(reflect.New(outt.Elem()))
+ }
+ return out.Interface().(Setter)
+}
+
+func clearMap(m reflect.Value) {
+ var none reflect.Value
+ for _, k := range m.MapKeys() {
+ m.SetMapIndex(k, none)
+ }
+}
+
+func (d *decoder) readDocTo(out reflect.Value) {
+ var elemType reflect.Type
+ outt := out.Type()
+ outk := outt.Kind()
+
+ for {
+ if outk == reflect.Ptr && out.IsNil() {
+ out.Set(reflect.New(outt.Elem()))
+ }
+ if setter := getSetter(outt, out); setter != nil {
+ raw := d.readRaw(ElementDocument)
+ err := setter.SetBSON(raw)
+ if _, ok := err.(*TypeError); err != nil && !ok {
+ panic(err)
+ }
+ return
+ }
+ if outk == reflect.Ptr {
+ out = out.Elem()
+ outt = out.Type()
+ outk = out.Kind()
+ continue
+ }
+ break
+ }
+
+ var fieldsMap map[string]fieldInfo
+ var inlineMap reflect.Value
+ if outt == typeRaw {
+ out.Set(reflect.ValueOf(d.readRaw(ElementDocument)))
+ return
+ }
+
+ origout := out
+ if outk == reflect.Interface {
+ if d.docType.Kind() == reflect.Map {
+ mv := reflect.MakeMap(d.docType)
+ out.Set(mv)
+ out = mv
+ } else {
+ dv := reflect.New(d.docType).Elem()
+ out.Set(dv)
+ out = dv
+ }
+ outt = out.Type()
+ outk = outt.Kind()
+ }
+
+ docType := d.docType
+ keyType := typeString
+ convertKey := false
+ switch outk {
+ case reflect.Map:
+ keyType = outt.Key()
+ if keyType != typeString {
+ convertKey = true
+ }
+ elemType = outt.Elem()
+ if elemType == typeIface {
+ d.docType = outt
+ }
+ if out.IsNil() {
+ out.Set(reflect.MakeMap(out.Type()))
+ } else if out.Len() > 0 {
+ clearMap(out)
+ }
+ case reflect.Struct:
+ sinfo, err := getStructInfo(out.Type())
+ if err != nil {
+ panic(err)
+ }
+ fieldsMap = sinfo.FieldsMap
+ out.Set(sinfo.Zero)
+ if sinfo.InlineMap != -1 {
+ inlineMap = out.Field(sinfo.InlineMap)
+ if !inlineMap.IsNil() && inlineMap.Len() > 0 {
+ clearMap(inlineMap)
+ }
+ elemType = inlineMap.Type().Elem()
+ if elemType == typeIface {
+ d.docType = inlineMap.Type()
+ }
+ }
+ case reflect.Slice:
+ switch outt.Elem() {
+ case typeDocElem:
+ origout.Set(d.readDocElems(outt))
+ return
+ case typeRawDocElem:
+ origout.Set(d.readRawDocElems(outt))
+ return
+ }
+ fallthrough
+ default:
+ panic("Unsupported document type for unmarshalling: " + out.Type().String())
+ }
+
+ end := int(d.readInt32())
+ end += d.i - 4
+ if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+ corrupted()
+ }
+ for d.in[d.i] != '\x00' {
+ kind := d.readByte()
+ name := d.readCStr()
+ if d.i >= end {
+ corrupted()
+ }
+
+ switch outk {
+ case reflect.Map:
+ e := reflect.New(elemType).Elem()
+ if d.readElemTo(e, kind) {
+ k := reflect.ValueOf(name)
+ if convertKey {
+ mapKeyType := out.Type().Key()
+ mapKeyKind := mapKeyType.Kind()
+
+ switch mapKeyKind {
+ case reflect.Int:
+ fallthrough
+ case reflect.Int8:
+ fallthrough
+ case reflect.Int16:
+ fallthrough
+ case reflect.Int32:
+ fallthrough
+ case reflect.Int64:
+ fallthrough
+ case reflect.Uint:
+ fallthrough
+ case reflect.Uint8:
+ fallthrough
+ case reflect.Uint16:
+ fallthrough
+ case reflect.Uint32:
+ fallthrough
+ case reflect.Uint64:
+ fallthrough
+ case reflect.Float32:
+ fallthrough
+ case reflect.Float64:
+ parsed := d.parseMapKeyAsFloat(k, mapKeyKind)
+ k = reflect.ValueOf(parsed)
+ case reflect.String:
+ mapKeyType = keyType
+ default:
+ panic("BSON map must have string or decimal keys. Got: " + outt.String())
+ }
+
+ k = k.Convert(mapKeyType)
+ }
+ out.SetMapIndex(k, e)
+ }
+ case reflect.Struct:
+ if info, ok := fieldsMap[name]; ok {
+ if info.Inline == nil {
+ d.readElemTo(out.Field(info.Num), kind)
+ } else {
+ d.readElemTo(out.FieldByIndex(info.Inline), kind)
+ }
+ } else if inlineMap.IsValid() {
+ if inlineMap.IsNil() {
+ inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
+ }
+ e := reflect.New(elemType).Elem()
+ if d.readElemTo(e, kind) {
+ inlineMap.SetMapIndex(reflect.ValueOf(name), e)
+ }
+ } else {
+ d.dropElem(kind)
+ }
+ case reflect.Slice:
+ }
+
+ if d.i >= end {
+ corrupted()
+ }
+ }
+ d.i++ // '\x00'
+ if d.i != end {
+ corrupted()
+ }
+ d.docType = docType
+}
+
+func (decoder) parseMapKeyAsFloat(k reflect.Value, mapKeyKind reflect.Kind) float64 {
+ parsed, err := strconv.ParseFloat(k.String(), 64)
+ if err != nil {
+ panic("Map key is defined to be a decimal type (" + mapKeyKind.String() + ") but got error " +
+ err.Error())
+ }
+
+ return parsed
+}
+
+func (d *decoder) readArrayDocTo(out reflect.Value) {
+ end := int(d.readInt32())
+ end += d.i - 4
+ if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+ corrupted()
+ }
+ i := 0
+ l := out.Len()
+ for d.in[d.i] != '\x00' {
+ if i >= l {
+ panic("Length mismatch on array field")
+ }
+ kind := d.readByte()
+ for d.i < end && d.in[d.i] != '\x00' {
+ d.i++
+ }
+ if d.i >= end {
+ corrupted()
+ }
+ d.i++
+ d.readElemTo(out.Index(i), kind)
+ if d.i >= end {
+ corrupted()
+ }
+ i++
+ }
+ if i != l {
+ panic("Length mismatch on array field")
+ }
+ d.i++ // '\x00'
+ if d.i != end {
+ corrupted()
+ }
+}
+
+func (d *decoder) readSliceDoc(t reflect.Type) interface{} {
+ tmp := make([]reflect.Value, 0, 8)
+ elemType := t.Elem()
+ if elemType == typeRawDocElem {
+ d.dropElem(ElementArray)
+ return reflect.Zero(t).Interface()
+ }
+ if elemType == typeRaw {
+ return d.readSliceOfRaw()
+ }
+
+ end := int(d.readInt32())
+ end += d.i - 4
+ if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+ corrupted()
+ }
+ for d.in[d.i] != '\x00' {
+ kind := d.readByte()
+ for d.i < end && d.in[d.i] != '\x00' {
+ d.i++
+ }
+ if d.i >= end {
+ corrupted()
+ }
+ d.i++
+ e := reflect.New(elemType).Elem()
+ if d.readElemTo(e, kind) {
+ tmp = append(tmp, e)
+ }
+ if d.i >= end {
+ corrupted()
+ }
+ }
+ d.i++ // '\x00'
+ if d.i != end {
+ corrupted()
+ }
+
+ n := len(tmp)
+ slice := reflect.MakeSlice(t, n, n)
+ for i := 0; i != n; i++ {
+ slice.Index(i).Set(tmp[i])
+ }
+ return slice.Interface()
+}
+
+func BSONElementSize(kind byte, offset int, buffer []byte) (int, error) {
+ switch kind {
+ case ElementFloat64: // Float64
+ return 8, nil
+ case ElementJavaScriptWithoutScope: // JavaScript without scope
+ fallthrough
+ case ElementSymbol: // Symbol
+ fallthrough
+ case ElementString: // UTF-8 string
+ size, err := getSize(offset, buffer)
+ if err != nil {
+ return 0, err
+ }
+ if size < 1 {
+ return 0, errors.New("String size can't be less then one byte")
+ }
+ size += 4
+ if offset+size > len(buffer) {
+ return 0, io.ErrUnexpectedEOF
+ }
+ if buffer[offset+size-1] != 0 {
+ return 0, errors.New("Invalid string: non zero-terminated")
+ }
+ return size, nil
+ case ElementArray: // Array
+ fallthrough
+ case ElementDocument: // Document
+ size, err := getSize(offset, buffer)
+ if err != nil {
+ return 0, err
+ }
+ if size < 5 {
+ return 0, errors.New("Declared document size is too small")
+ }
+ return size, nil
+ case ElementBinary: // Binary
+ size, err := getSize(offset, buffer)
+ if err != nil {
+ return 0, err
+ }
+ if size < 0 {
+ return 0, errors.New("Binary data size can't be negative")
+ }
+ return size + 5, nil
+ case Element06: // Undefined (obsolete, but still seen in the wild)
+ return 0, nil
+ case ElementObjectId: // ObjectId
+ return 12, nil
+ case ElementBool: // Bool
+ return 1, nil
+ case ElementDatetime: // Timestamp
+ return 8, nil
+ case ElementNil: // Nil
+ return 0, nil
+ case ElementRegEx: // RegEx
+ end := offset
+ for i := 0; i < 2; i++ {
+ for end < len(buffer) && buffer[end] != '\x00' {
+ end++
+ }
+ end++
+ }
+ if end > len(buffer) {
+ return 0, io.ErrUnexpectedEOF
+ }
+ return end - offset, nil
+ case ElementDBPointer: // DBPointer
+ size, err := getSize(offset, buffer)
+ if err != nil {
+ return 0, err
+ }
+ if size < 1 {
+ return 0, errors.New("String size can't be less then one byte")
+ }
+ return size + 12 + 4, nil
+ case ElementJavaScriptWithScope: // JavaScript with scope
+ size, err := getSize(offset, buffer)
+ if err != nil {
+ return 0, err
+ }
+ if size < 4+5+5 {
+ return 0, errors.New("Declared document element is too small")
+ }
+ return size, nil
+ case ElementInt32: // Int32
+ return 4, nil
+ case ElementTimestamp: // Mongo-specific timestamp
+ return 8, nil
+ case ElementInt64: // Int64
+ return 8, nil
+ case ElementDecimal128: // Decimal128
+ return 16, nil
+ case ElementMaxKey: // Max key
+ return 0, nil
+ case ElementMinKey: // Min key
+ return 0, nil
+ default:
+ return 0, errors.New(fmt.Sprintf("Unknown element kind (0x%02X)", kind))
+ }
+}
+
+func (d *decoder) readRaw(kind byte) Raw {
+ size, err := BSONElementSize(kind, d.i, d.in)
+ if err != nil {
+ corrupted()
+ }
+ if d.i+size > len(d.in) {
+ corrupted()
+ }
+ d.i += size
+ return Raw{
+ Kind: kind,
+ Data: d.in[d.i-size : d.i],
+ }
+}
+
+func (d *decoder) readSliceOfRaw() interface{} {
+ tmp := make([]Raw, 0, 8)
+ end := int(d.readInt32())
+ end += d.i - 4
+ if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+ corrupted()
+ }
+ for d.in[d.i] != '\x00' {
+ kind := d.readByte()
+ for d.i < end && d.in[d.i] != '\x00' {
+ d.i++
+ }
+ if d.i >= end {
+ corrupted()
+ }
+ d.i++
+ e := d.readRaw(kind)
+ tmp = append(tmp, e)
+ if d.i >= end {
+ corrupted()
+ }
+ }
+ d.i++ // '\x00'
+ if d.i != end {
+ corrupted()
+ }
+ return tmp
+}
+
+var typeSlice = reflect.TypeOf([]interface{}{})
+var typeIface = typeSlice.Elem()
+
+func (d *decoder) readDocElems(typ reflect.Type) reflect.Value {
+ docType := d.docType
+ d.docType = typ
+ slice := make([]DocElem, 0, 8)
+ d.readDocWith(func(kind byte, name string) {
+ e := DocElem{Name: name}
+ v := reflect.ValueOf(&e.Value)
+ if d.readElemTo(v.Elem(), kind) {
+ slice = append(slice, e)
+ }
+ })
+ slicev := reflect.New(typ).Elem()
+ slicev.Set(reflect.ValueOf(slice))
+ d.docType = docType
+ return slicev
+}
+
+func (d *decoder) readRawDocElems(typ reflect.Type) reflect.Value {
+ docType := d.docType
+ d.docType = typ
+ slice := make([]RawDocElem, 0, 8)
+ d.readDocWith(func(kind byte, name string) {
+ e := RawDocElem{Name: name, Value: d.readRaw(kind)}
+ slice = append(slice, e)
+ })
+ slicev := reflect.New(typ).Elem()
+ slicev.Set(reflect.ValueOf(slice))
+ d.docType = docType
+ return slicev
+}
+
+func (d *decoder) readDocWith(f func(kind byte, name string)) {
+ end := int(d.readInt32())
+ end += d.i - 4
+ if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+ corrupted()
+ }
+ for d.in[d.i] != '\x00' {
+ kind := d.readByte()
+ name := d.readCStr()
+ if d.i >= end {
+ corrupted()
+ }
+ f(kind, name)
+ if d.i >= end {
+ corrupted()
+ }
+ }
+ d.i++ // '\x00'
+ if d.i != end {
+ corrupted()
+ }
+}
+
+// --------------------------------------------------------------------------
+// Unmarshaling of individual elements within a document.
+func (d *decoder) dropElem(kind byte) {
+ size, err := BSONElementSize(kind, d.i, d.in)
+ if err != nil {
+ corrupted()
+ }
+ if d.i+size > len(d.in) {
+ corrupted()
+ }
+ d.i += size
+}
+
+// Attempt to decode an element from the document and put it into out.
+// If the types are not compatible, the returned ok value will be
+// false and out will be unchanged.
+func (d *decoder) readElemTo(out reflect.Value, kind byte) (good bool) {
+ outt := out.Type()
+
+ if outt == typeRaw {
+ out.Set(reflect.ValueOf(d.readRaw(kind)))
+ return true
+ }
+
+ if outt == typeRawPtr {
+ raw := d.readRaw(kind)
+ out.Set(reflect.ValueOf(&raw))
+ return true
+ }
+
+ if kind == ElementDocument {
+ // Delegate unmarshaling of documents.
+ outt := out.Type()
+ outk := out.Kind()
+ switch outk {
+ case reflect.Interface, reflect.Ptr, reflect.Struct, reflect.Map:
+ d.readDocTo(out)
+ return true
+ }
+ if setterStyle(outt) != setterNone {
+ d.readDocTo(out)
+ return true
+ }
+ if outk == reflect.Slice {
+ switch outt.Elem() {
+ case typeDocElem:
+ out.Set(d.readDocElems(outt))
+ case typeRawDocElem:
+ out.Set(d.readRawDocElems(outt))
+ default:
+ d.dropElem(kind)
+ }
+ return true
+ }
+ d.dropElem(kind)
+ return true
+ }
+
+ if setter := getSetter(outt, out); setter != nil {
+ err := setter.SetBSON(d.readRaw(kind))
+ if err == ErrSetZero {
+ out.Set(reflect.Zero(outt))
+ return true
+ }
+ if err == nil {
+ return true
+ }
+ if _, ok := err.(*TypeError); !ok {
+ panic(err)
+ }
+ return false
+ }
+
+ var in interface{}
+
+ switch kind {
+ case ElementFloat64:
+ in = d.readFloat64()
+ case ElementString:
+ in = d.readStr()
+ case ElementDocument:
+ panic("Can't happen. Handled above.")
+ case ElementArray:
+ outt := out.Type()
+ if setterStyle(outt) != setterNone {
+ // Skip the value so its data is handed to the setter below.
+ d.dropElem(kind)
+ break
+ }
+ for outt.Kind() == reflect.Ptr {
+ outt = outt.Elem()
+ }
+ switch outt.Kind() {
+ case reflect.Array:
+ d.readArrayDocTo(out)
+ return true
+ case reflect.Slice:
+ in = d.readSliceDoc(outt)
+ default:
+ in = d.readSliceDoc(typeSlice)
+ }
+ case ElementBinary:
+ b := d.readBinary()
+ if b.Kind == BinaryGeneric || b.Kind == BinaryBinaryOld {
+ in = b.Data
+ } else {
+ in = b
+ }
+ case Element06: // Undefined (obsolete, but still seen in the wild)
+ in = Undefined
+ case ElementObjectId:
+ in = ObjectId(d.readBytes(12))
+ case ElementBool:
+ in = d.readBool()
+ case ElementDatetime: // Timestamp
+ // MongoDB handles timestamps as milliseconds.
+ i := d.readInt64()
+ if i == -62135596800000 {
+ in = time.Time{} // In UTC for convenience.
+ } else {
+ in = time.Unix(i/1e3, i%1e3*1e6).UTC()
+ }
+ case ElementNil:
+ in = nil
+ case ElementRegEx:
+ in = d.readRegEx()
+ case ElementDBPointer:
+ in = DBPointer{Namespace: d.readStr(), Id: ObjectId(d.readBytes(12))}
+ case ElementJavaScriptWithoutScope:
+ in = JavaScript{Code: d.readStr()}
+ case ElementSymbol:
+ in = Symbol(d.readStr())
+ case ElementJavaScriptWithScope:
+ start := d.i
+ l := int(d.readInt32())
+ js := JavaScript{d.readStr(), make(M)}
+ d.readDocTo(reflect.ValueOf(js.Scope))
+ if d.i != start+l {
+ corrupted()
+ }
+ in = js
+ case ElementInt32:
+ in = int(d.readInt32())
+ case ElementTimestamp: // Mongo-specific timestamp
+ in = MongoTimestamp(d.readInt64())
+ case ElementInt64:
+ switch out.Type() {
+ case typeTimeDuration:
+ in = time.Duration(time.Duration(d.readInt64()) * time.Millisecond)
+ default:
+ in = d.readInt64()
+ }
+ case ElementDecimal128:
+ in = Decimal128{
+ l: uint64(d.readInt64()),
+ h: uint64(d.readInt64()),
+ }
+ case ElementMaxKey:
+ in = MaxKey
+ case ElementMinKey:
+ in = MinKey
+ default:
+ panic(fmt.Sprintf("Unknown element kind (0x%02X)", kind))
+ }
+
+ if in == nil {
+ out.Set(reflect.Zero(outt))
+ return true
+ }
+
+ outk := outt.Kind()
+
+ // Dereference and initialize pointer if necessary.
+ first := true
+ for outk == reflect.Ptr {
+ if !out.IsNil() {
+ out = out.Elem()
+ } else {
+ elem := reflect.New(outt.Elem())
+ if first {
+ // Only set if value is compatible.
+ first = false
+ defer func(out, elem reflect.Value) {
+ if good {
+ out.Set(elem)
+ }
+ }(out, elem)
+ } else {
+ out.Set(elem)
+ }
+ out = elem
+ }
+ outt = out.Type()
+ outk = outt.Kind()
+ }
+
+ inv := reflect.ValueOf(in)
+ if outt == inv.Type() {
+ out.Set(inv)
+ return true
+ }
+
+ switch outk {
+ case reflect.Interface:
+ out.Set(inv)
+ return true
+ case reflect.String:
+ switch inv.Kind() {
+ case reflect.String:
+ out.SetString(inv.String())
+ return true
+ case reflect.Slice:
+ if b, ok := in.([]byte); ok {
+ out.SetString(string(b))
+ return true
+ }
+ case reflect.Int, reflect.Int64:
+ if outt == typeJSONNumber {
+ out.SetString(strconv.FormatInt(inv.Int(), 10))
+ return true
+ }
+ case reflect.Float64:
+ if outt == typeJSONNumber {
+ out.SetString(strconv.FormatFloat(inv.Float(), 'f', -1, 64))
+ return true
+ }
+ }
+ case reflect.Slice, reflect.Array:
+ // Remember, array (0x04) slices are built with the correct
+ // element type. If we are here, must be a cross BSON kind
+ // conversion (e.g. 0x05 unmarshalling on string).
+ if outt.Elem().Kind() != reflect.Uint8 {
+ break
+ }
+ switch inv.Kind() {
+ case reflect.String:
+ slice := []byte(inv.String())
+ out.Set(reflect.ValueOf(slice))
+ return true
+ case reflect.Slice:
+ switch outt.Kind() {
+ case reflect.Array:
+ reflect.Copy(out, inv)
+ case reflect.Slice:
+ out.SetBytes(inv.Bytes())
+ }
+ return true
+ }
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ switch inv.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ out.SetInt(inv.Int())
+ return true
+ case reflect.Float32, reflect.Float64:
+ out.SetInt(int64(inv.Float()))
+ return true
+ case reflect.Bool:
+ if inv.Bool() {
+ out.SetInt(1)
+ } else {
+ out.SetInt(0)
+ }
+ return true
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ panic("can't happen: no uint types in BSON (!?)")
+ }
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ switch inv.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ out.SetUint(uint64(inv.Int()))
+ return true
+ case reflect.Float32, reflect.Float64:
+ out.SetUint(uint64(inv.Float()))
+ return true
+ case reflect.Bool:
+ if inv.Bool() {
+ out.SetUint(1)
+ } else {
+ out.SetUint(0)
+ }
+ return true
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ panic("Can't happen. No uint types in BSON.")
+ }
+ case reflect.Float32, reflect.Float64:
+ switch inv.Kind() {
+ case reflect.Float32, reflect.Float64:
+ out.SetFloat(inv.Float())
+ return true
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ out.SetFloat(float64(inv.Int()))
+ return true
+ case reflect.Bool:
+ if inv.Bool() {
+ out.SetFloat(1)
+ } else {
+ out.SetFloat(0)
+ }
+ return true
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ panic("Can't happen. No uint types in BSON?")
+ }
+ case reflect.Bool:
+ switch inv.Kind() {
+ case reflect.Bool:
+ out.SetBool(inv.Bool())
+ return true
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ out.SetBool(inv.Int() != 0)
+ return true
+ case reflect.Float32, reflect.Float64:
+ out.SetBool(inv.Float() != 0)
+ return true
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ panic("Can't happen. No uint types in BSON?")
+ }
+ case reflect.Struct:
+ if outt == typeURL && inv.Kind() == reflect.String {
+ u, err := url.Parse(inv.String())
+ if err != nil {
+ panic(err)
+ }
+ out.Set(reflect.ValueOf(u).Elem())
+ return true
+ }
+ if outt == typeBinary {
+ if b, ok := in.([]byte); ok {
+ out.Set(reflect.ValueOf(Binary{Data: b}))
+ return true
+ }
+ }
+ }
+
+ return false
+}
+
+// --------------------------------------------------------------------------
+// Parsers of basic types.
+
+func (d *decoder) readRegEx() RegEx {
+ re := RegEx{}
+ re.Pattern = d.readCStr()
+ re.Options = d.readCStr()
+ return re
+}
+
+func (d *decoder) readBinary() Binary {
+ l := d.readInt32()
+ b := Binary{}
+ b.Kind = d.readByte()
+ if b.Kind == BinaryBinaryOld && l > 4 {
+ // Weird obsolete format with redundant length.
+ rl := d.readInt32()
+ if rl != l-4 {
+ corrupted()
+ }
+ l = rl
+ }
+ b.Data = d.readBytes(l)
+ return b
+}
+
+func (d *decoder) readStr() string {
+ l := d.readInt32()
+ b := d.readBytes(l - 1)
+ if d.readByte() != '\x00' {
+ corrupted()
+ }
+ return string(b)
+}
+
+func (d *decoder) readCStr() string {
+ start := d.i
+ end := start
+ l := len(d.in)
+ for ; end != l; end++ {
+ if d.in[end] == '\x00' {
+ break
+ }
+ }
+ d.i = end + 1
+ if d.i > l {
+ corrupted()
+ }
+ return string(d.in[start:end])
+}
+
+func (d *decoder) readBool() bool {
+ b := d.readByte()
+ if b == 0 {
+ return false
+ }
+ if b == 1 {
+ return true
+ }
+ panic(fmt.Sprintf("encoded boolean must be 1 or 0, found %d", b))
+}
+
+func (d *decoder) readFloat64() float64 {
+ return math.Float64frombits(uint64(d.readInt64()))
+}
+
+func (d *decoder) readInt32() int32 {
+ b := d.readBytes(4)
+ return int32((uint32(b[0]) << 0) |
+ (uint32(b[1]) << 8) |
+ (uint32(b[2]) << 16) |
+ (uint32(b[3]) << 24))
+}
+
+func getSize(offset int, b []byte) (int, error) {
+ if offset+4 > len(b) {
+ return 0, io.ErrUnexpectedEOF
+ }
+ return int((uint32(b[offset]) << 0) |
+ (uint32(b[offset+1]) << 8) |
+ (uint32(b[offset+2]) << 16) |
+ (uint32(b[offset+3]) << 24)), nil
+}
+
+func (d *decoder) readInt64() int64 {
+ b := d.readBytes(8)
+ return int64((uint64(b[0]) << 0) |
+ (uint64(b[1]) << 8) |
+ (uint64(b[2]) << 16) |
+ (uint64(b[3]) << 24) |
+ (uint64(b[4]) << 32) |
+ (uint64(b[5]) << 40) |
+ (uint64(b[6]) << 48) |
+ (uint64(b[7]) << 56))
+}
+
+func (d *decoder) readByte() byte {
+ i := d.i
+ d.i++
+ if d.i > len(d.in) {
+ corrupted()
+ }
+ return d.in[i]
+}
+
+func (d *decoder) readBytes(length int32) []byte {
+ if length < 0 {
+ corrupted()
+ }
+ start := d.i
+ d.i += int(length)
+ if d.i < start || d.i > len(d.in) {
+ corrupted()
+ }
+ return d.in[start : start+int(length)]
+}
diff --git a/vendor/github.com/globalsign/mgo/bson/encode.go b/vendor/github.com/globalsign/mgo/bson/encode.go
new file mode 100644
index 0000000000..d0c6b2a855
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/encode.go
@@ -0,0 +1,645 @@
+// BSON library for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// gobson - BSON library for Go.
+
+package bson
+
+import (
+ "encoding/json"
+ "fmt"
+ "math"
+ "net/url"
+ "reflect"
+ "sort"
+ "strconv"
+ "sync"
+ "time"
+)
+
+// --------------------------------------------------------------------------
+// Some internal infrastructure.
+
+var (
+ typeBinary = reflect.TypeOf(Binary{})
+ typeObjectId = reflect.TypeOf(ObjectId(""))
+ typeDBPointer = reflect.TypeOf(DBPointer{"", ObjectId("")})
+ typeSymbol = reflect.TypeOf(Symbol(""))
+ typeMongoTimestamp = reflect.TypeOf(MongoTimestamp(0))
+ typeOrderKey = reflect.TypeOf(MinKey)
+ typeDocElem = reflect.TypeOf(DocElem{})
+ typeRawDocElem = reflect.TypeOf(RawDocElem{})
+ typeRaw = reflect.TypeOf(Raw{})
+ typeRawPtr = reflect.PtrTo(reflect.TypeOf(Raw{}))
+ typeURL = reflect.TypeOf(url.URL{})
+ typeTime = reflect.TypeOf(time.Time{})
+ typeString = reflect.TypeOf("")
+ typeJSONNumber = reflect.TypeOf(json.Number(""))
+ typeTimeDuration = reflect.TypeOf(time.Duration(0))
+)
+
+var (
+ // spec for []uint8 or []byte encoding
+ arrayOps = map[string]bool{
+ "$in": true,
+ "$nin": true,
+ "$all": true,
+ }
+)
+
+const itoaCacheSize = 32
+
+const (
+ getterUnknown = iota
+ getterNone
+ getterTypeVal
+ getterTypePtr
+ getterAddr
+)
+
+var itoaCache []string
+
+var getterStyles map[reflect.Type]int
+var getterIface reflect.Type
+var getterMutex sync.RWMutex
+
+func init() {
+ itoaCache = make([]string, itoaCacheSize)
+ for i := 0; i != itoaCacheSize; i++ {
+ itoaCache[i] = strconv.Itoa(i)
+ }
+ var iface Getter
+ getterIface = reflect.TypeOf(&iface).Elem()
+ getterStyles = make(map[reflect.Type]int)
+}
+
+func itoa(i int) string {
+ if i < itoaCacheSize {
+ return itoaCache[i]
+ }
+ return strconv.Itoa(i)
+}
+
+func getterStyle(outt reflect.Type) int {
+ getterMutex.RLock()
+ style := getterStyles[outt]
+ getterMutex.RUnlock()
+ if style != getterUnknown {
+ return style
+ }
+
+ getterMutex.Lock()
+ defer getterMutex.Unlock()
+ if outt.Implements(getterIface) {
+ vt := outt
+ for vt.Kind() == reflect.Ptr {
+ vt = vt.Elem()
+ }
+ if vt.Implements(getterIface) {
+ style = getterTypeVal
+ } else {
+ style = getterTypePtr
+ }
+ } else if reflect.PtrTo(outt).Implements(getterIface) {
+ style = getterAddr
+ } else {
+ style = getterNone
+ }
+ getterStyles[outt] = style
+ return style
+}
+
+func getGetter(outt reflect.Type, out reflect.Value) Getter {
+ style := getterStyle(outt)
+ if style == getterNone {
+ return nil
+ }
+ if style == getterAddr {
+ if !out.CanAddr() {
+ return nil
+ }
+ return out.Addr().Interface().(Getter)
+ }
+ if style == getterTypeVal && out.Kind() == reflect.Ptr && out.IsNil() {
+ return nil
+ }
+ return out.Interface().(Getter)
+}
+
+// --------------------------------------------------------------------------
+// Marshaling of the document value itself.
+
+type encoder struct {
+ out []byte
+}
+
+func (e *encoder) addDoc(v reflect.Value) {
+ for {
+ if vi, ok := v.Interface().(Getter); ok {
+ getv, err := vi.GetBSON()
+ if err != nil {
+ panic(err)
+ }
+ v = reflect.ValueOf(getv)
+ continue
+ }
+ if v.Kind() == reflect.Ptr {
+ v = v.Elem()
+ continue
+ }
+ break
+ }
+
+ if v.Type() == typeRaw {
+ raw := v.Interface().(Raw)
+ if raw.Kind != 0x03 && raw.Kind != 0x00 {
+ panic("Attempted to marshal Raw kind " + strconv.Itoa(int(raw.Kind)) + " as a document")
+ }
+ if len(raw.Data) == 0 {
+ panic("Attempted to marshal empty Raw document")
+ }
+ e.addBytes(raw.Data...)
+ return
+ }
+
+ start := e.reserveInt32()
+
+ switch v.Kind() {
+ case reflect.Map:
+ e.addMap(v)
+ case reflect.Struct:
+ e.addStruct(v)
+ case reflect.Array, reflect.Slice:
+ e.addSlice(v)
+ default:
+ panic("Can't marshal " + v.Type().String() + " as a BSON document")
+ }
+
+ e.addBytes(0)
+ e.setInt32(start, int32(len(e.out)-start))
+}
+
+func (e *encoder) addMap(v reflect.Value) {
+ for _, k := range v.MapKeys() {
+ e.addElem(fmt.Sprint(k), v.MapIndex(k), false)
+ }
+}
+
+func (e *encoder) addStruct(v reflect.Value) {
+ sinfo, err := getStructInfo(v.Type())
+ if err != nil {
+ panic(err)
+ }
+ var value reflect.Value
+ if sinfo.InlineMap >= 0 {
+ m := v.Field(sinfo.InlineMap)
+ if m.Len() > 0 {
+ for _, k := range m.MapKeys() {
+ ks := k.String()
+ if _, found := sinfo.FieldsMap[ks]; found {
+ panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", ks))
+ }
+ e.addElem(ks, m.MapIndex(k), false)
+ }
+ }
+ }
+ for _, info := range sinfo.FieldsList {
+ if info.Inline == nil {
+ value = v.Field(info.Num)
+ } else {
+ // as pointers to struct are allowed here,
+ // there is no guarantee that pointer won't be nil.
+ //
+ // It is expected allowed behaviour
+ // so info.Inline MAY consist index to a nil pointer
+ // and that is why we safely call v.FieldByIndex and just continue on panic
+ field, errField := safeFieldByIndex(v, info.Inline)
+ if errField != nil {
+ continue
+ }
+
+ value = field
+ }
+ if info.OmitEmpty && isZero(value) {
+ continue
+ }
+ if useRespectNilValues &&
+ (value.Kind() == reflect.Slice || value.Kind() == reflect.Map) &&
+ value.IsNil() {
+ e.addElem(info.Key, reflect.ValueOf(nil), info.MinSize)
+ continue
+ }
+ e.addElem(info.Key, value, info.MinSize)
+ }
+}
+
+func safeFieldByIndex(v reflect.Value, index []int) (result reflect.Value, err error) {
+ defer func() {
+ if recovered := recover(); recovered != nil {
+ switch r := recovered.(type) {
+ case string:
+ err = fmt.Errorf("%s", r)
+ case error:
+ err = r
+ }
+ }
+ }()
+
+ result = v.FieldByIndex(index)
+ return
+}
+
+func isZero(v reflect.Value) bool {
+ switch v.Kind() {
+ case reflect.String:
+ return len(v.String()) == 0
+ case reflect.Ptr, reflect.Interface:
+ return v.IsNil()
+ case reflect.Slice:
+ return v.Len() == 0
+ case reflect.Map:
+ return v.Len() == 0
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v.Uint() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Struct:
+ vt := v.Type()
+ if vt == typeTime {
+ return v.Interface().(time.Time).IsZero()
+ }
+ for i := 0; i < v.NumField(); i++ {
+ if vt.Field(i).PkgPath != "" && !vt.Field(i).Anonymous {
+ continue // Private field
+ }
+ if !isZero(v.Field(i)) {
+ return false
+ }
+ }
+ return true
+ }
+ return false
+}
+
+func (e *encoder) addSlice(v reflect.Value) {
+ vi := v.Interface()
+ if d, ok := vi.(D); ok {
+ for _, elem := range d {
+ e.addElem(elem.Name, reflect.ValueOf(elem.Value), false)
+ }
+ return
+ }
+ if d, ok := vi.(RawD); ok {
+ for _, elem := range d {
+ e.addElem(elem.Name, reflect.ValueOf(elem.Value), false)
+ }
+ return
+ }
+ l := v.Len()
+ et := v.Type().Elem()
+ if et == typeDocElem {
+ for i := 0; i < l; i++ {
+ elem := v.Index(i).Interface().(DocElem)
+ e.addElem(elem.Name, reflect.ValueOf(elem.Value), false)
+ }
+ return
+ }
+ if et == typeRawDocElem {
+ for i := 0; i < l; i++ {
+ elem := v.Index(i).Interface().(RawDocElem)
+ e.addElem(elem.Name, reflect.ValueOf(elem.Value), false)
+ }
+ return
+ }
+ for i := 0; i < l; i++ {
+ e.addElem(itoa(i), v.Index(i), false)
+ }
+}
+
+// --------------------------------------------------------------------------
+// Marshaling of elements in a document.
+
+func (e *encoder) addElemName(kind byte, name string) {
+ e.addBytes(kind)
+ e.addBytes([]byte(name)...)
+ e.addBytes(0)
+}
+
+func (e *encoder) addElem(name string, v reflect.Value, minSize bool) {
+
+ if !v.IsValid() {
+ e.addElemName(0x0A, name)
+ return
+ }
+
+ if getter := getGetter(v.Type(), v); getter != nil {
+ getv, err := getter.GetBSON()
+ if err != nil {
+ panic(err)
+ }
+ e.addElem(name, reflect.ValueOf(getv), minSize)
+ return
+ }
+
+ switch v.Kind() {
+
+ case reflect.Interface:
+ e.addElem(name, v.Elem(), minSize)
+
+ case reflect.Ptr:
+ e.addElem(name, v.Elem(), minSize)
+
+ case reflect.String:
+ s := v.String()
+ switch v.Type() {
+ case typeObjectId:
+ if len(s) != 12 {
+ panic("ObjectIDs must be exactly 12 bytes long (got " +
+ strconv.Itoa(len(s)) + ")")
+ }
+ e.addElemName(0x07, name)
+ e.addBytes([]byte(s)...)
+ case typeSymbol:
+ e.addElemName(0x0E, name)
+ e.addStr(s)
+ case typeJSONNumber:
+ n := v.Interface().(json.Number)
+ if i, err := n.Int64(); err == nil {
+ e.addElemName(0x12, name)
+ e.addInt64(i)
+ } else if f, err := n.Float64(); err == nil {
+ e.addElemName(0x01, name)
+ e.addFloat64(f)
+ } else {
+ panic("failed to convert json.Number to a number: " + s)
+ }
+ default:
+ e.addElemName(0x02, name)
+ e.addStr(s)
+ }
+
+ case reflect.Float32, reflect.Float64:
+ e.addElemName(0x01, name)
+ e.addFloat64(v.Float())
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ u := v.Uint()
+ if int64(u) < 0 {
+ panic("BSON has no uint64 type, and value is too large to fit correctly in an int64")
+ } else if u <= math.MaxInt32 && (minSize || v.Kind() <= reflect.Uint32) {
+ e.addElemName(0x10, name)
+ e.addInt32(int32(u))
+ } else {
+ e.addElemName(0x12, name)
+ e.addInt64(int64(u))
+ }
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ switch v.Type() {
+ case typeMongoTimestamp:
+ e.addElemName(0x11, name)
+ e.addInt64(v.Int())
+
+ case typeOrderKey:
+ if v.Int() == int64(MaxKey) {
+ e.addElemName(0x7F, name)
+ } else {
+ e.addElemName(0xFF, name)
+ }
+ case typeTimeDuration:
+ // Stored as int64
+ e.addElemName(0x12, name)
+
+ e.addInt64(int64(v.Int() / 1e6))
+ default:
+ i := v.Int()
+ if (minSize || v.Type().Kind() != reflect.Int64) && i >= math.MinInt32 && i <= math.MaxInt32 {
+ // It fits into an int32, encode as such.
+ e.addElemName(0x10, name)
+ e.addInt32(int32(i))
+ } else {
+ e.addElemName(0x12, name)
+ e.addInt64(i)
+ }
+ }
+
+ case reflect.Bool:
+ e.addElemName(0x08, name)
+ if v.Bool() {
+ e.addBytes(1)
+ } else {
+ e.addBytes(0)
+ }
+
+ case reflect.Map:
+ e.addElemName(0x03, name)
+ e.addDoc(v)
+
+ case reflect.Slice:
+ vt := v.Type()
+ et := vt.Elem()
+ if et.Kind() == reflect.Uint8 {
+ if arrayOps[name] {
+ e.addElemName(0x04, name)
+ e.addDoc(v)
+ } else {
+ e.addElemName(0x05, name)
+ e.addBinary(0x00, v.Bytes())
+ }
+ } else if et == typeDocElem || et == typeRawDocElem {
+ e.addElemName(0x03, name)
+ e.addDoc(v)
+ } else {
+ e.addElemName(0x04, name)
+ e.addDoc(v)
+ }
+
+ case reflect.Array:
+ et := v.Type().Elem()
+ if et.Kind() == reflect.Uint8 {
+ if arrayOps[name] {
+ e.addElemName(0x04, name)
+ e.addDoc(v)
+ } else {
+ e.addElemName(0x05, name)
+ if v.CanAddr() {
+ e.addBinary(0x00, v.Slice(0, v.Len()).Interface().([]byte))
+ } else {
+ n := v.Len()
+ e.addInt32(int32(n))
+ e.addBytes(0x00)
+ for i := 0; i < n; i++ {
+ el := v.Index(i)
+ e.addBytes(byte(el.Uint()))
+ }
+ }
+ }
+ } else {
+ e.addElemName(0x04, name)
+ e.addDoc(v)
+ }
+
+ case reflect.Struct:
+ switch s := v.Interface().(type) {
+
+ case Raw:
+ kind := s.Kind
+ if kind == 0x00 {
+ kind = 0x03
+ }
+ if len(s.Data) == 0 && kind != 0x06 && kind != 0x0A && kind != 0xFF && kind != 0x7F {
+ panic("Attempted to marshal empty Raw document")
+ }
+ e.addElemName(kind, name)
+ e.addBytes(s.Data...)
+
+ case Binary:
+ e.addElemName(0x05, name)
+ e.addBinary(s.Kind, s.Data)
+
+ case Decimal128:
+ e.addElemName(0x13, name)
+ e.addInt64(int64(s.l))
+ e.addInt64(int64(s.h))
+
+ case DBPointer:
+ e.addElemName(0x0C, name)
+ e.addStr(s.Namespace)
+ if len(s.Id) != 12 {
+ panic("ObjectIDs must be exactly 12 bytes long (got " +
+ strconv.Itoa(len(s.Id)) + ")")
+ }
+ e.addBytes([]byte(s.Id)...)
+
+ case RegEx:
+ e.addElemName(0x0B, name)
+ e.addCStr(s.Pattern)
+ options := runes(s.Options)
+ sort.Sort(options)
+ e.addCStr(string(options))
+
+ case JavaScript:
+ if s.Scope == nil {
+ e.addElemName(0x0D, name)
+ e.addStr(s.Code)
+ } else {
+ e.addElemName(0x0F, name)
+ start := e.reserveInt32()
+ e.addStr(s.Code)
+ e.addDoc(reflect.ValueOf(s.Scope))
+ e.setInt32(start, int32(len(e.out)-start))
+ }
+
+ case time.Time:
+ // MongoDB handles timestamps as milliseconds.
+ e.addElemName(0x09, name)
+ e.addInt64(s.Unix()*1000 + int64(s.Nanosecond()/1e6))
+
+ case url.URL:
+ e.addElemName(0x02, name)
+ e.addStr(s.String())
+
+ case undefined:
+ e.addElemName(0x06, name)
+
+ default:
+ e.addElemName(0x03, name)
+ e.addDoc(v)
+ }
+
+ default:
+ panic("Can't marshal " + v.Type().String() + " in a BSON document")
+ }
+}
+
+// -------------
+// Helper method for sorting regex options
+type runes []rune
+
+func (a runes) Len() int { return len(a) }
+func (a runes) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a runes) Less(i, j int) bool { return a[i] < a[j] }
+
+// --------------------------------------------------------------------------
+// Marshaling of base types.
+
+func (e *encoder) addBinary(subtype byte, v []byte) {
+ if subtype == 0x02 {
+ // Wonder how that brilliant idea came to life. Obsolete, luckily.
+ e.addInt32(int32(len(v) + 4))
+ e.addBytes(subtype)
+ e.addInt32(int32(len(v)))
+ } else {
+ e.addInt32(int32(len(v)))
+ e.addBytes(subtype)
+ }
+ e.addBytes(v...)
+}
+
+func (e *encoder) addStr(v string) {
+ e.addInt32(int32(len(v) + 1))
+ e.addCStr(v)
+}
+
+func (e *encoder) addCStr(v string) {
+ e.addBytes([]byte(v)...)
+ e.addBytes(0)
+}
+
+func (e *encoder) reserveInt32() (pos int) {
+ pos = len(e.out)
+ e.addBytes(0, 0, 0, 0)
+ return pos
+}
+
+func (e *encoder) setInt32(pos int, v int32) {
+ e.out[pos+0] = byte(v)
+ e.out[pos+1] = byte(v >> 8)
+ e.out[pos+2] = byte(v >> 16)
+ e.out[pos+3] = byte(v >> 24)
+}
+
+func (e *encoder) addInt32(v int32) {
+ u := uint32(v)
+ e.addBytes(byte(u), byte(u>>8), byte(u>>16), byte(u>>24))
+}
+
+func (e *encoder) addInt64(v int64) {
+ u := uint64(v)
+ e.addBytes(byte(u), byte(u>>8), byte(u>>16), byte(u>>24),
+ byte(u>>32), byte(u>>40), byte(u>>48), byte(u>>56))
+}
+
+func (e *encoder) addFloat64(v float64) {
+ e.addInt64(int64(math.Float64bits(v)))
+}
+
+func (e *encoder) addBytes(v ...byte) {
+ e.out = append(e.out, v...)
+}
diff --git a/vendor/github.com/globalsign/mgo/bson/json.go b/vendor/github.com/globalsign/mgo/bson/json.go
new file mode 100644
index 0000000000..045c713012
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/json.go
@@ -0,0 +1,384 @@
+package bson
+
+import (
+ "bytes"
+ "encoding/base64"
+ "fmt"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/globalsign/mgo/internal/json"
+)
+
+// UnmarshalJSON unmarshals a JSON value that may hold non-standard
+// syntax as defined in BSON's extended JSON specification.
+func UnmarshalJSON(data []byte, value interface{}) error {
+ d := json.NewDecoder(bytes.NewBuffer(data))
+ d.Extend(&jsonExt)
+ return d.Decode(value)
+}
+
+// MarshalJSON marshals a JSON value that may hold non-standard
+// syntax as defined in BSON's extended JSON specification.
+func MarshalJSON(value interface{}) ([]byte, error) {
+ var buf bytes.Buffer
+ e := json.NewEncoder(&buf)
+ e.Extend(&jsonExt)
+ err := e.Encode(value)
+ if err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil
+}
+
+// jdec is used internally by the JSON decoding functions
+// so they may unmarshal functions without getting into endless
+// recursion due to keyed objects.
+func jdec(data []byte, value interface{}) error {
+ d := json.NewDecoder(bytes.NewBuffer(data))
+ d.Extend(&funcExt)
+ return d.Decode(value)
+}
+
+var jsonExt json.Extension
+var funcExt json.Extension
+
+// TODO
+// - Shell regular expressions ("/regexp/opts")
+
+func init() {
+ jsonExt.DecodeUnquotedKeys(true)
+ jsonExt.DecodeTrailingCommas(true)
+
+ funcExt.DecodeFunc("BinData", "$binaryFunc", "$type", "$binary")
+ jsonExt.DecodeKeyed("$binary", jdecBinary)
+ jsonExt.DecodeKeyed("$binaryFunc", jdecBinary)
+ jsonExt.EncodeType([]byte(nil), jencBinarySlice)
+ jsonExt.EncodeType(Binary{}, jencBinaryType)
+
+ funcExt.DecodeFunc("ISODate", "$dateFunc", "S")
+ funcExt.DecodeFunc("new Date", "$dateFunc", "S")
+ jsonExt.DecodeKeyed("$date", jdecDate)
+ jsonExt.DecodeKeyed("$dateFunc", jdecDate)
+ jsonExt.EncodeType(time.Time{}, jencDate)
+
+ funcExt.DecodeFunc("Timestamp", "$timestamp", "t", "i")
+ jsonExt.DecodeKeyed("$timestamp", jdecTimestamp)
+ jsonExt.EncodeType(MongoTimestamp(0), jencTimestamp)
+
+ funcExt.DecodeConst("undefined", Undefined)
+
+ jsonExt.DecodeKeyed("$regex", jdecRegEx)
+ jsonExt.EncodeType(RegEx{}, jencRegEx)
+
+ funcExt.DecodeFunc("ObjectId", "$oidFunc", "Id")
+ jsonExt.DecodeKeyed("$oid", jdecObjectId)
+ jsonExt.DecodeKeyed("$oidFunc", jdecObjectId)
+ jsonExt.EncodeType(ObjectId(""), jencObjectId)
+
+ funcExt.DecodeFunc("DBRef", "$dbrefFunc", "$ref", "$id")
+ jsonExt.DecodeKeyed("$dbrefFunc", jdecDBRef)
+
+ funcExt.DecodeFunc("NumberLong", "$numberLongFunc", "N")
+ jsonExt.DecodeKeyed("$numberLong", jdecNumberLong)
+ jsonExt.DecodeKeyed("$numberLongFunc", jdecNumberLong)
+ jsonExt.EncodeType(int64(0), jencNumberLong)
+ jsonExt.EncodeType(int(0), jencInt)
+
+ funcExt.DecodeConst("MinKey", MinKey)
+ funcExt.DecodeConst("MaxKey", MaxKey)
+ jsonExt.DecodeKeyed("$minKey", jdecMinKey)
+ jsonExt.DecodeKeyed("$maxKey", jdecMaxKey)
+ jsonExt.EncodeType(orderKey(0), jencMinMaxKey)
+
+ jsonExt.DecodeKeyed("$undefined", jdecUndefined)
+ jsonExt.EncodeType(Undefined, jencUndefined)
+
+ jsonExt.Extend(&funcExt)
+}
+
+func fbytes(format string, args ...interface{}) []byte {
+ var buf bytes.Buffer
+ fmt.Fprintf(&buf, format, args...)
+ return buf.Bytes()
+}
+
+func jdecBinary(data []byte) (interface{}, error) {
+ var v struct {
+ Binary []byte `json:"$binary"`
+ Type string `json:"$type"`
+ Func struct {
+ Binary []byte `json:"$binary"`
+ Type int64 `json:"$type"`
+ } `json:"$binaryFunc"`
+ }
+ err := jdec(data, &v)
+ if err != nil {
+ return nil, err
+ }
+
+ var binData []byte
+ var binKind int64
+ if v.Type == "" && v.Binary == nil {
+ binData = v.Func.Binary
+ binKind = v.Func.Type
+ } else if v.Type == "" {
+ return v.Binary, nil
+ } else {
+ binData = v.Binary
+ binKind, err = strconv.ParseInt(v.Type, 0, 64)
+ if err != nil {
+ binKind = -1
+ }
+ }
+
+ if binKind == 0 {
+ return binData, nil
+ }
+ if binKind < 0 || binKind > 255 {
+ return nil, fmt.Errorf("invalid type in binary object: %s", data)
+ }
+
+ return Binary{Kind: byte(binKind), Data: binData}, nil
+}
+
+func jencBinarySlice(v interface{}) ([]byte, error) {
+ in := v.([]byte)
+ out := make([]byte, base64.StdEncoding.EncodedLen(len(in)))
+ base64.StdEncoding.Encode(out, in)
+ return fbytes(`{"$binary":"%s","$type":"0x0"}`, out), nil
+}
+
+func jencBinaryType(v interface{}) ([]byte, error) {
+ in := v.(Binary)
+ out := make([]byte, base64.StdEncoding.EncodedLen(len(in.Data)))
+ base64.StdEncoding.Encode(out, in.Data)
+ return fbytes(`{"$binary":"%s","$type":"0x%x"}`, out, in.Kind), nil
+}
+
+const jdateFormat = "2006-01-02T15:04:05.999Z07:00"
+
+func jdecDate(data []byte) (interface{}, error) {
+ var v struct {
+ S string `json:"$date"`
+ Func struct {
+ S string
+ } `json:"$dateFunc"`
+ }
+ _ = jdec(data, &v)
+ if v.S == "" {
+ v.S = v.Func.S
+ }
+ if v.S != "" {
+ var errs []string
+ for _, format := range []string{jdateFormat, "2006-01-02"} {
+ t, err := time.Parse(format, v.S)
+ if err == nil {
+ return t, nil
+ }
+ errs = append(errs, err.Error())
+ }
+ return nil, fmt.Errorf("cannot parse date: %q [%s]", v.S, strings.Join(errs, ", "))
+ }
+
+ var vn struct {
+ Date struct {
+ N int64 `json:"$numberLong,string"`
+ } `json:"$date"`
+ Func struct {
+ S int64
+ } `json:"$dateFunc"`
+ }
+ err := jdec(data, &vn)
+ if err != nil {
+ return nil, fmt.Errorf("cannot parse date: %q", data)
+ }
+ n := vn.Date.N
+ if n == 0 {
+ n = vn.Func.S
+ }
+ return time.Unix(n/1000, n%1000*1e6).UTC(), nil
+}
+
+func jencDate(v interface{}) ([]byte, error) {
+ t := v.(time.Time)
+ return fbytes(`{"$date":%q}`, t.Format(jdateFormat)), nil
+}
+
+func jdecTimestamp(data []byte) (interface{}, error) {
+ var v struct {
+ Func struct {
+ T int32 `json:"t"`
+ I int32 `json:"i"`
+ } `json:"$timestamp"`
+ }
+ err := jdec(data, &v)
+ if err != nil {
+ return nil, err
+ }
+ return MongoTimestamp(uint64(v.Func.T)<<32 | uint64(uint32(v.Func.I))), nil
+}
+
+func jencTimestamp(v interface{}) ([]byte, error) {
+ ts := uint64(v.(MongoTimestamp))
+ return fbytes(`{"$timestamp":{"t":%d,"i":%d}}`, ts>>32, uint32(ts)), nil
+}
+
+func jdecRegEx(data []byte) (interface{}, error) {
+ var v struct {
+ Regex string `json:"$regex"`
+ Options string `json:"$options"`
+ }
+ err := jdec(data, &v)
+ if err != nil {
+ return nil, err
+ }
+ return RegEx{v.Regex, v.Options}, nil
+}
+
+func jencRegEx(v interface{}) ([]byte, error) {
+ re := v.(RegEx)
+ type regex struct {
+ Regex string `json:"$regex"`
+ Options string `json:"$options"`
+ }
+ return json.Marshal(regex{re.Pattern, re.Options})
+}
+
+func jdecObjectId(data []byte) (interface{}, error) {
+ var v struct {
+ Id string `json:"$oid"`
+ Func struct {
+ Id string
+ } `json:"$oidFunc"`
+ }
+ err := jdec(data, &v)
+ if err != nil {
+ return nil, err
+ }
+ if v.Id == "" {
+ v.Id = v.Func.Id
+ }
+ return ObjectIdHex(v.Id), nil
+}
+
+func jencObjectId(v interface{}) ([]byte, error) {
+ return fbytes(`{"$oid":"%s"}`, v.(ObjectId).Hex()), nil
+}
+
+func jdecDBRef(data []byte) (interface{}, error) {
+ // TODO Support unmarshaling $ref and $id into the input value.
+ var v struct {
+ Obj map[string]interface{} `json:"$dbrefFunc"`
+ }
+ // TODO Fix this. Must not be required.
+ v.Obj = make(map[string]interface{})
+ err := jdec(data, &v)
+ if err != nil {
+ return nil, err
+ }
+ return v.Obj, nil
+}
+
+func jdecNumberLong(data []byte) (interface{}, error) {
+ var v struct {
+ N int64 `json:"$numberLong,string"`
+ Func struct {
+ N int64 `json:",string"`
+ } `json:"$numberLongFunc"`
+ }
+ var vn struct {
+ N int64 `json:"$numberLong"`
+ Func struct {
+ N int64
+ } `json:"$numberLongFunc"`
+ }
+ err := jdec(data, &v)
+ if err != nil {
+ err = jdec(data, &vn)
+ v.N = vn.N
+ v.Func.N = vn.Func.N
+ }
+ if err != nil {
+ return nil, err
+ }
+ if v.N != 0 {
+ return v.N, nil
+ }
+ return v.Func.N, nil
+}
+
+func jencNumberLong(v interface{}) ([]byte, error) {
+ n := v.(int64)
+ f := `{"$numberLong":"%d"}`
+ if n <= 1<<53 {
+ f = `{"$numberLong":%d}`
+ }
+ return fbytes(f, n), nil
+}
+
+func jencInt(v interface{}) ([]byte, error) {
+ n := v.(int)
+ f := `{"$numberLong":"%d"}`
+ if int64(n) <= 1<<53 {
+ f = `%d`
+ }
+ return fbytes(f, n), nil
+}
+
+func jdecMinKey(data []byte) (interface{}, error) {
+ var v struct {
+ N int64 `json:"$minKey"`
+ }
+ err := jdec(data, &v)
+ if err != nil {
+ return nil, err
+ }
+ if v.N != 1 {
+ return nil, fmt.Errorf("invalid $minKey object: %s", data)
+ }
+ return MinKey, nil
+}
+
+func jdecMaxKey(data []byte) (interface{}, error) {
+ var v struct {
+ N int64 `json:"$maxKey"`
+ }
+ err := jdec(data, &v)
+ if err != nil {
+ return nil, err
+ }
+ if v.N != 1 {
+ return nil, fmt.Errorf("invalid $maxKey object: %s", data)
+ }
+ return MaxKey, nil
+}
+
+func jencMinMaxKey(v interface{}) ([]byte, error) {
+ switch v.(orderKey) {
+ case MinKey:
+ return []byte(`{"$minKey":1}`), nil
+ case MaxKey:
+ return []byte(`{"$maxKey":1}`), nil
+ }
+ panic(fmt.Sprintf("invalid $minKey/$maxKey value: %d", v))
+}
+
+func jdecUndefined(data []byte) (interface{}, error) {
+ var v struct {
+ B bool `json:"$undefined"`
+ }
+ err := jdec(data, &v)
+ if err != nil {
+ return nil, err
+ }
+ if !v.B {
+ return nil, fmt.Errorf("invalid $undefined object: %s", data)
+ }
+ return Undefined, nil
+}
+
+func jencUndefined(v interface{}) ([]byte, error) {
+ return []byte(`{"$undefined":true}`), nil
+}
diff --git a/vendor/github.com/globalsign/mgo/bson/stream.go b/vendor/github.com/globalsign/mgo/bson/stream.go
new file mode 100644
index 0000000000..466528457b
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bson/stream.go
@@ -0,0 +1,90 @@
+package bson
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "io"
+)
+
+const (
+ // MinDocumentSize is the size of the smallest possible valid BSON document:
+ // an int32 size header + 0x00 (end of document).
+ MinDocumentSize = 5
+
+ // MaxDocumentSize is the largest possible size for a BSON document allowed by MongoDB,
+ // that is, 16 MiB (see https://docs.mongodb.com/manual/reference/limits/).
+ MaxDocumentSize = 16777216
+)
+
+// ErrInvalidDocumentSize is an error returned when a BSON document's header
+// contains a size smaller than MinDocumentSize or greater than MaxDocumentSize.
+type ErrInvalidDocumentSize struct {
+ DocumentSize int32
+}
+
+func (e ErrInvalidDocumentSize) Error() string {
+ return fmt.Sprintf("invalid document size %d", e.DocumentSize)
+}
+
+// A Decoder reads and decodes BSON values from an input stream.
+type Decoder struct {
+ source io.Reader
+}
+
+// NewDecoder returns a new Decoder that reads from source.
+// It does not add any extra buffering, and may not read data from source beyond the BSON values requested.
+func NewDecoder(source io.Reader) *Decoder {
+ return &Decoder{source: source}
+}
+
+// Decode reads the next BSON-encoded value from its input and stores it in the value pointed to by v.
+// See the documentation for Unmarshal for details about the conversion of BSON into a Go value.
+func (dec *Decoder) Decode(v interface{}) (err error) {
+ // BSON documents start with their size as a *signed* int32.
+ var docSize int32
+ if err = binary.Read(dec.source, binary.LittleEndian, &docSize); err != nil {
+ return
+ }
+
+ if docSize < MinDocumentSize || docSize > MaxDocumentSize {
+ return ErrInvalidDocumentSize{DocumentSize: docSize}
+ }
+
+ docBuffer := bytes.NewBuffer(make([]byte, 0, docSize))
+ if err = binary.Write(docBuffer, binary.LittleEndian, docSize); err != nil {
+ return
+ }
+
+ // docSize is the *full* document's size (including the 4-byte size header,
+ // which has already been read).
+ if _, err = io.CopyN(docBuffer, dec.source, int64(docSize-4)); err != nil {
+ return
+ }
+
+ // Let Unmarshal handle the rest.
+ defer handleErr(&err)
+ return Unmarshal(docBuffer.Bytes(), v)
+}
+
+// An Encoder encodes and writes BSON values to an output stream.
+type Encoder struct {
+ target io.Writer
+}
+
+// NewEncoder returns a new Encoder that writes to target.
+func NewEncoder(target io.Writer) *Encoder {
+ return &Encoder{target: target}
+}
+
+// Encode encodes v to BSON, and if successful writes it to the Encoder's output stream.
+// See the documentation for Marshal for details about the conversion of Go values to BSON.
+func (enc *Encoder) Encode(v interface{}) error {
+ data, err := Marshal(v)
+ if err != nil {
+ return err
+ }
+
+ _, err = enc.target.Write(data)
+ return err
+}
diff --git a/vendor/github.com/globalsign/mgo/bulk.go b/vendor/github.com/globalsign/mgo/bulk.go
new file mode 100644
index 0000000000..c234fcceee
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/bulk.go
@@ -0,0 +1,366 @@
+package mgo
+
+import (
+ "bytes"
+ "sort"
+ "sync"
+
+ "github.com/globalsign/mgo/bson"
+)
+
+// Bulk represents an operation that can be prepared with several
+// orthogonal changes before being delivered to the server.
+//
+// MongoDB servers older than version 2.6 do not have proper support for bulk
+// operations, so the driver attempts to map its API as much as possible into
+// the functionality that works. In particular, in those releases updates and
+// removals are sent individually, and inserts are sent in bulk but have
+// suboptimal error reporting compared to more recent versions of the server.
+// See the documentation of BulkErrorCase for details on that.
+//
+// Relevant documentation:
+//
+// http://blog.mongodb.org/post/84922794768/mongodbs-new-bulk-api
+//
+type Bulk struct {
+ c *Collection
+ opcount int
+ actions []bulkAction
+ ordered bool
+}
+
+type bulkOp int
+
+const (
+ bulkInsert bulkOp = iota + 1
+ bulkUpdate
+ bulkUpdateAll
+ bulkRemove
+)
+
+type bulkAction struct {
+ op bulkOp
+ docs []interface{}
+ idxs []int
+}
+
+type bulkUpdateOp []interface{}
+type bulkDeleteOp []interface{}
+
+// BulkResult holds the results for a bulk operation.
+type BulkResult struct {
+ Matched int
+ Modified int // Available only for MongoDB 2.6+
+
+ // Be conservative while we understand exactly how to report these
+ // results in a useful and convenient way, and also how to emulate
+ // them with prior servers.
+ private bool
+}
+
+// BulkError holds an error returned from running a Bulk operation.
+// Individual errors may be obtained and inspected via the Cases method.
+type BulkError struct {
+ ecases []BulkErrorCase
+}
+
+func (e *BulkError) Error() string {
+ if len(e.ecases) == 0 {
+ return "invalid BulkError instance: no errors"
+ }
+ if len(e.ecases) == 1 {
+ return e.ecases[0].Err.Error()
+ }
+ msgs := make([]string, 0, len(e.ecases))
+ seen := make(map[string]bool)
+ for _, ecase := range e.ecases {
+ msg := ecase.Err.Error()
+ if !seen[msg] {
+ seen[msg] = true
+ msgs = append(msgs, msg)
+ }
+ }
+ if len(msgs) == 1 {
+ return msgs[0]
+ }
+ var buf bytes.Buffer
+ buf.WriteString("multiple errors in bulk operation:\n")
+ for _, msg := range msgs {
+ buf.WriteString(" - ")
+ buf.WriteString(msg)
+ buf.WriteByte('\n')
+ }
+ return buf.String()
+}
+
+type bulkErrorCases []BulkErrorCase
+
+func (slice bulkErrorCases) Len() int { return len(slice) }
+func (slice bulkErrorCases) Less(i, j int) bool { return slice[i].Index < slice[j].Index }
+func (slice bulkErrorCases) Swap(i, j int) { slice[i], slice[j] = slice[j], slice[i] }
+
+// BulkErrorCase holds an individual error found while attempting a single change
+// within a bulk operation, and the position in which it was enqueued.
+//
+// MongoDB servers older than version 2.6 do not have proper support for bulk
+// operations, so the driver attempts to map its API as much as possible into
+// the functionality that works. In particular, only the last error is reported
+// for bulk inserts and without any positional information, so the Index
+// field is set to -1 in these cases.
+type BulkErrorCase struct {
+ Index int // Position of operation that failed, or -1 if unknown.
+ Err error
+}
+
+// Cases returns all individual errors found while attempting the requested changes.
+//
+// See the documentation of BulkErrorCase for limitations in older MongoDB releases.
+func (e *BulkError) Cases() []BulkErrorCase {
+ return e.ecases
+}
+
+var actionPool = sync.Pool{
+ New: func() interface{} {
+ return &bulkAction{
+ docs: make([]interface{}, 0),
+ idxs: make([]int, 0),
+ }
+ },
+}
+
+// Bulk returns a value to prepare the execution of a bulk operation.
+func (c *Collection) Bulk() *Bulk {
+ return &Bulk{c: c, ordered: true}
+}
+
+// Unordered puts the bulk operation in unordered mode.
+//
+// In unordered mode the indvidual operations may be sent
+// out of order, which means latter operations may proceed
+// even if prior ones have failed.
+func (b *Bulk) Unordered() {
+ b.ordered = false
+}
+
+func (b *Bulk) action(op bulkOp, opcount int) *bulkAction {
+ var action *bulkAction
+ if len(b.actions) > 0 && b.actions[len(b.actions)-1].op == op {
+ action = &b.actions[len(b.actions)-1]
+ } else if !b.ordered {
+ for i := range b.actions {
+ if b.actions[i].op == op {
+ action = &b.actions[i]
+ break
+ }
+ }
+ }
+ if action == nil {
+ a := actionPool.Get().(*bulkAction)
+ a.op = op
+ b.actions = append(b.actions, *a)
+ action = &b.actions[len(b.actions)-1]
+ }
+ for i := 0; i < opcount; i++ {
+ action.idxs = append(action.idxs, b.opcount)
+ b.opcount++
+ }
+ return action
+}
+
+// Insert queues up the provided documents for insertion.
+func (b *Bulk) Insert(docs ...interface{}) {
+ action := b.action(bulkInsert, len(docs))
+ action.docs = append(action.docs, docs...)
+}
+
+// Remove queues up the provided selectors for removing matching documents.
+// Each selector will remove only a single matching document.
+func (b *Bulk) Remove(selectors ...interface{}) {
+ action := b.action(bulkRemove, len(selectors))
+ for _, selector := range selectors {
+ if selector == nil {
+ selector = bson.D{}
+ }
+ action.docs = append(action.docs, &deleteOp{
+ Collection: b.c.FullName,
+ Selector: selector,
+ Flags: 1,
+ Limit: 1,
+ })
+ }
+}
+
+// RemoveAll queues up the provided selectors for removing all matching documents.
+// Each selector will remove all matching documents.
+func (b *Bulk) RemoveAll(selectors ...interface{}) {
+ action := b.action(bulkRemove, len(selectors))
+ for _, selector := range selectors {
+ if selector == nil {
+ selector = bson.D{}
+ }
+ action.docs = append(action.docs, &deleteOp{
+ Collection: b.c.FullName,
+ Selector: selector,
+ Flags: 0,
+ Limit: 0,
+ })
+ }
+}
+
+// Update queues up the provided pairs of updating instructions.
+// The first element of each pair selects which documents must be
+// updated, and the second element defines how to update it.
+// Each pair matches exactly one document for updating at most.
+func (b *Bulk) Update(pairs ...interface{}) {
+ if len(pairs)%2 != 0 {
+ panic("Bulk.Update requires an even number of parameters")
+ }
+ action := b.action(bulkUpdate, len(pairs)/2)
+ for i := 0; i < len(pairs); i += 2 {
+ selector := pairs[i]
+ if selector == nil {
+ selector = bson.D{}
+ }
+ action.docs = append(action.docs, &updateOp{
+ Collection: b.c.FullName,
+ Selector: selector,
+ Update: pairs[i+1],
+ })
+ }
+}
+
+// UpdateAll queues up the provided pairs of updating instructions.
+// The first element of each pair selects which documents must be
+// updated, and the second element defines how to update it.
+// Each pair updates all documents matching the selector.
+func (b *Bulk) UpdateAll(pairs ...interface{}) {
+ if len(pairs)%2 != 0 {
+ panic("Bulk.UpdateAll requires an even number of parameters")
+ }
+ action := b.action(bulkUpdate, len(pairs)/2)
+ for i := 0; i < len(pairs); i += 2 {
+ selector := pairs[i]
+ if selector == nil {
+ selector = bson.D{}
+ }
+ action.docs = append(action.docs, &updateOp{
+ Collection: b.c.FullName,
+ Selector: selector,
+ Update: pairs[i+1],
+ Flags: 2,
+ Multi: true,
+ })
+ }
+}
+
+// Upsert queues up the provided pairs of upserting instructions.
+// The first element of each pair selects which documents must be
+// updated, and the second element defines how to update it.
+// Each pair matches exactly one document for updating at most.
+func (b *Bulk) Upsert(pairs ...interface{}) {
+ if len(pairs)%2 != 0 {
+ panic("Bulk.Update requires an even number of parameters")
+ }
+ action := b.action(bulkUpdate, len(pairs)/2)
+ for i := 0; i < len(pairs); i += 2 {
+ selector := pairs[i]
+ if selector == nil {
+ selector = bson.D{}
+ }
+ action.docs = append(action.docs, &updateOp{
+ Collection: b.c.FullName,
+ Selector: selector,
+ Update: pairs[i+1],
+ Flags: 1,
+ Upsert: true,
+ })
+ }
+}
+
+// Run runs all the operations queued up.
+//
+// If an error is reported on an unordered bulk operation, the error value may
+// be an aggregation of all issues observed. As an exception to that, Insert
+// operations running on MongoDB versions prior to 2.6 will report the last
+// error only due to a limitation in the wire protocol.
+func (b *Bulk) Run() (*BulkResult, error) {
+ var result BulkResult
+ var berr BulkError
+ var failed bool
+ for i := range b.actions {
+ action := &b.actions[i]
+ var ok bool
+ switch action.op {
+ case bulkInsert:
+ ok = b.runInsert(action, &result, &berr)
+ case bulkUpdate:
+ ok = b.runUpdate(action, &result, &berr)
+ case bulkRemove:
+ ok = b.runRemove(action, &result, &berr)
+ default:
+ panic("unknown bulk operation")
+ }
+ action.idxs = action.idxs[0:0]
+ action.docs = action.docs[0:0]
+ actionPool.Put(action)
+ if !ok {
+ failed = true
+ if b.ordered {
+ break
+ }
+ }
+ }
+ if failed {
+ sort.Sort(bulkErrorCases(berr.ecases))
+ return nil, &berr
+ }
+ return &result, nil
+}
+
+func (b *Bulk) runInsert(action *bulkAction, result *BulkResult, berr *BulkError) bool {
+ op := &insertOp{b.c.FullName, action.docs, 0}
+ if !b.ordered {
+ op.flags = 1 // ContinueOnError
+ }
+ lerr, err := b.c.writeOp(op, b.ordered)
+ return b.checkSuccess(action, berr, lerr, err)
+}
+
+func (b *Bulk) runUpdate(action *bulkAction, result *BulkResult, berr *BulkError) bool {
+ lerr, err := b.c.writeOp(bulkUpdateOp(action.docs), b.ordered)
+ if lerr != nil {
+ result.Matched += lerr.N
+ result.Modified += lerr.modified
+ }
+ return b.checkSuccess(action, berr, lerr, err)
+}
+
+func (b *Bulk) runRemove(action *bulkAction, result *BulkResult, berr *BulkError) bool {
+ lerr, err := b.c.writeOp(bulkDeleteOp(action.docs), b.ordered)
+ if lerr != nil {
+ result.Matched += lerr.N
+ result.Modified += lerr.modified
+ }
+ return b.checkSuccess(action, berr, lerr, err)
+}
+
+func (b *Bulk) checkSuccess(action *bulkAction, berr *BulkError, lerr *LastError, err error) bool {
+ if lerr != nil && len(lerr.ecases) > 0 {
+ for i := 0; i < len(lerr.ecases); i++ {
+ // Map back from the local error index into the visible one.
+ ecase := lerr.ecases[i]
+ idx := ecase.Index
+ if idx >= 0 {
+ idx = action.idxs[idx]
+ }
+ berr.ecases = append(berr.ecases, BulkErrorCase{idx, ecase.Err})
+ }
+ return false
+ } else if err != nil {
+ for i := 0; i < len(action.idxs); i++ {
+ berr.ecases = append(berr.ecases, BulkErrorCase{action.idxs[i], err})
+ }
+ return false
+ }
+ return true
+}
diff --git a/vendor/github.com/globalsign/mgo/changestreams.go b/vendor/github.com/globalsign/mgo/changestreams.go
new file mode 100644
index 0000000000..5c2279c66e
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/changestreams.go
@@ -0,0 +1,357 @@
+package mgo
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "sync"
+ "time"
+
+ "github.com/globalsign/mgo/bson"
+)
+
+type FullDocument string
+
+const (
+ Default = "default"
+ UpdateLookup = "updateLookup"
+)
+
+type ChangeStream struct {
+ iter *Iter
+ isClosed bool
+ options ChangeStreamOptions
+ pipeline interface{}
+ resumeToken *bson.Raw
+ collection *Collection
+ readPreference *ReadPreference
+ err error
+ m sync.Mutex
+ sessionCopied bool
+}
+
+type ChangeStreamOptions struct {
+
+ // FullDocument controls the amount of data that the server will return when
+ // returning a changes document.
+ FullDocument FullDocument
+
+ // ResumeAfter specifies the logical starting point for the new change stream.
+ ResumeAfter *bson.Raw
+
+ // MaxAwaitTimeMS specifies the maximum amount of time for the server to wait
+ // on new documents to satisfy a change stream query.
+ MaxAwaitTimeMS time.Duration
+
+ // BatchSize specifies the number of documents to return per batch.
+ BatchSize int
+
+ // Collation specifies the way the server should collate returned data.
+ //TODO Collation *Collation
+}
+
+var errMissingResumeToken = errors.New("resume token missing from result")
+
+// Watch constructs a new ChangeStream capable of receiving continuing data
+// from the database.
+func (coll *Collection) Watch(pipeline interface{},
+ options ChangeStreamOptions) (*ChangeStream, error) {
+
+ if pipeline == nil {
+ pipeline = []bson.M{}
+ }
+
+ csPipe := constructChangeStreamPipeline(pipeline, options)
+ pipe := coll.Pipe(&csPipe)
+ if options.MaxAwaitTimeMS > 0 {
+ pipe.SetMaxTime(options.MaxAwaitTimeMS)
+ }
+ if options.BatchSize > 0 {
+ pipe.Batch(options.BatchSize)
+ }
+ pIter := pipe.Iter()
+
+ // check that there was no issue creating the iterator.
+ // this will fail immediately with an error from the server if running against
+ // a standalone.
+ if err := pIter.Err(); err != nil {
+ return nil, err
+ }
+
+ pIter.isChangeStream = true
+ return &ChangeStream{
+ iter: pIter,
+ collection: coll,
+ resumeToken: nil,
+ options: options,
+ pipeline: pipeline,
+ }, nil
+}
+
+// Next retrieves the next document from the change stream, blocking if necessary.
+// Next returns true if a document was successfully unmarshalled into result,
+// and false if an error occured. When Next returns false, the Err method should
+// be called to check what error occurred during iteration. If there were no events
+// available (ErrNotFound), the Err method returns nil so the user can retry the invocaton.
+//
+// For example:
+//
+// pipeline := []bson.M{}
+//
+// changeStream := collection.Watch(pipeline, ChangeStreamOptions{})
+// for changeStream.Next(&changeDoc) {
+// fmt.Printf("Change: %v\n", changeDoc)
+// }
+//
+// if err := changeStream.Close(); err != nil {
+// return err
+// }
+//
+// If the pipeline used removes the _id field from the result, Next will error
+// because the _id field is needed to resume iteration when an error occurs.
+//
+func (changeStream *ChangeStream) Next(result interface{}) bool {
+ // the err field is being constantly overwritten and we don't want the user to
+ // attempt to read it at this point so we lock.
+ changeStream.m.Lock()
+
+ defer changeStream.m.Unlock()
+
+ // if we are in a state of error, then don't continue.
+ if changeStream.err != nil {
+ return false
+ }
+
+ if changeStream.isClosed {
+ changeStream.err = fmt.Errorf("illegal use of a closed ChangeStream")
+ return false
+ }
+
+ var err error
+
+ // attempt to fetch the change stream result.
+ err = changeStream.fetchResultSet(result)
+ if err == nil {
+ return true
+ }
+
+ // if we get no results we return false with no errors so the user can call Next
+ // again, resuming is not needed as the iterator is simply timed out as no events happened.
+ // The user will call Timeout in order to understand if this was the case.
+ if err == ErrNotFound {
+ return false
+ }
+
+ // check if the error is resumable
+ if !isResumableError(err) {
+ // error is not resumable, give up and return it to the user.
+ changeStream.err = err
+ return false
+ }
+
+ // try to resume.
+ err = changeStream.resume()
+ if err != nil {
+ // we've not been able to successfully resume and should only try once,
+ // so we give up.
+ changeStream.err = err
+ return false
+ }
+
+ // we've successfully resumed the changestream.
+ // try to fetch the next result.
+ err = changeStream.fetchResultSet(result)
+ if err != nil {
+ changeStream.err = err
+ return false
+ }
+
+ return true
+}
+
+// Err returns nil if no errors happened during iteration, or the actual
+// error otherwise.
+func (changeStream *ChangeStream) Err() error {
+ changeStream.m.Lock()
+ defer changeStream.m.Unlock()
+ return changeStream.err
+}
+
+// Close kills the server cursor used by the iterator, if any, and returns
+// nil if no errors happened during iteration, or the actual error otherwise.
+func (changeStream *ChangeStream) Close() error {
+ changeStream.m.Lock()
+ defer changeStream.m.Unlock()
+ changeStream.isClosed = true
+ err := changeStream.iter.Close()
+ if err != nil {
+ changeStream.err = err
+ }
+ if changeStream.sessionCopied {
+ changeStream.iter.session.Close()
+ changeStream.sessionCopied = false
+ }
+ return err
+}
+
+// ResumeToken returns a copy of the current resume token held by the change stream.
+// This token should be treated as an opaque token that can be provided to instantiate
+// a new change stream.
+func (changeStream *ChangeStream) ResumeToken() *bson.Raw {
+ changeStream.m.Lock()
+ defer changeStream.m.Unlock()
+ if changeStream.resumeToken == nil {
+ return nil
+ }
+ var tokenCopy = *changeStream.resumeToken
+ return &tokenCopy
+}
+
+// Timeout returns true if the last call of Next returned false because of an iterator timeout.
+func (changeStream *ChangeStream) Timeout() bool {
+ return changeStream.iter.Timeout()
+}
+
+func constructChangeStreamPipeline(pipeline interface{},
+ options ChangeStreamOptions) interface{} {
+ pipelinev := reflect.ValueOf(pipeline)
+
+ // ensure that the pipeline passed in is a slice.
+ if pipelinev.Kind() != reflect.Slice {
+ panic("pipeline argument must be a slice")
+ }
+
+ // construct the options to be used by the change notification
+ // pipeline stage.
+ changeStreamStageOptions := bson.M{}
+
+ if options.FullDocument != "" {
+ changeStreamStageOptions["fullDocument"] = options.FullDocument
+ }
+ if options.ResumeAfter != nil {
+ changeStreamStageOptions["resumeAfter"] = options.ResumeAfter
+ }
+
+ changeStreamStage := bson.M{"$changeStream": changeStreamStageOptions}
+
+ pipeOfInterfaces := make([]interface{}, pipelinev.Len()+1)
+
+ // insert the change notification pipeline stage at the beginning of the
+ // aggregation.
+ pipeOfInterfaces[0] = changeStreamStage
+
+ // convert the passed in slice to a slice of interfaces.
+ for i := 0; i < pipelinev.Len(); i++ {
+ pipeOfInterfaces[1+i] = pipelinev.Index(i).Addr().Interface()
+ }
+ var pipelineAsInterface interface{} = pipeOfInterfaces
+ return pipelineAsInterface
+}
+
+func (changeStream *ChangeStream) resume() error {
+ // copy the information for the new socket.
+
+ // Thanks to Copy() future uses will acquire a new socket against the newly selected DB.
+ newSession := changeStream.iter.session.Copy()
+
+ // fetch the cursor from the iterator and use it to run a killCursors
+ // on the connection.
+ cursorId := changeStream.iter.op.cursorId
+ err := runKillCursorsOnSession(newSession, cursorId)
+ if err != nil {
+ return err
+ }
+
+ // change out the old connection to the database with the new connection.
+ if changeStream.sessionCopied {
+ changeStream.collection.Database.Session.Close()
+ }
+ changeStream.collection.Database.Session = newSession
+ changeStream.sessionCopied = true
+
+ opts := changeStream.options
+ if changeStream.resumeToken != nil {
+ opts.ResumeAfter = changeStream.resumeToken
+ }
+ // make a new pipeline containing the resume token.
+ changeStreamPipeline := constructChangeStreamPipeline(changeStream.pipeline, opts)
+
+ // generate the new iterator with the new connection.
+ newPipe := changeStream.collection.Pipe(changeStreamPipeline)
+ changeStream.iter = newPipe.Iter()
+ if err := changeStream.iter.Err(); err != nil {
+ return err
+ }
+ changeStream.iter.isChangeStream = true
+ return nil
+}
+
+// fetchResumeToken unmarshals the _id field from the document, setting an error
+// on the changeStream if it is unable to.
+func (changeStream *ChangeStream) fetchResumeToken(rawResult *bson.Raw) error {
+ changeStreamResult := struct {
+ ResumeToken *bson.Raw `bson:"_id,omitempty"`
+ }{}
+
+ err := rawResult.Unmarshal(&changeStreamResult)
+ if err != nil {
+ return err
+ }
+
+ if changeStreamResult.ResumeToken == nil {
+ return errMissingResumeToken
+ }
+
+ changeStream.resumeToken = changeStreamResult.ResumeToken
+ return nil
+}
+
+func (changeStream *ChangeStream) fetchResultSet(result interface{}) error {
+ rawResult := bson.Raw{}
+
+ // fetch the next set of documents from the cursor.
+ gotNext := changeStream.iter.Next(&rawResult)
+ err := changeStream.iter.Err()
+ if err != nil {
+ return err
+ }
+
+ if !gotNext && err == nil {
+ // If the iter.Err() method returns nil despite us not getting a next batch,
+ // it is becuase iter.Err() silences this case.
+ return ErrNotFound
+ }
+
+ // grab the resumeToken from the results
+ if err := changeStream.fetchResumeToken(&rawResult); err != nil {
+ return err
+ }
+
+ // put the raw results into the data structure the user provided.
+ if err := rawResult.Unmarshal(result); err != nil {
+ return err
+ }
+ return nil
+}
+
+func isResumableError(err error) bool {
+ _, isQueryError := err.(*QueryError)
+ // if it is not a database error OR it is a database error,
+ // but the error is a notMaster error
+ //and is not a missingResumeToken error (caused by the user provided pipeline)
+ return (!isQueryError || isNotMasterError(err)) && (err != errMissingResumeToken)
+}
+
+func runKillCursorsOnSession(session *Session, cursorId int64) error {
+ socket, err := session.acquireSocket(true)
+ if err != nil {
+ return err
+ }
+ err = socket.Query(&killCursorsOp{[]int64{cursorId}})
+ if err != nil {
+ return err
+ }
+ socket.Release()
+
+ return nil
+}
diff --git a/vendor/github.com/globalsign/mgo/cluster.go b/vendor/github.com/globalsign/mgo/cluster.go
new file mode 100644
index 0000000000..ff431cac50
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/cluster.go
@@ -0,0 +1,704 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package mgo
+
+import (
+ "errors"
+ "fmt"
+ "net"
+ "runtime"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/globalsign/mgo/bson"
+)
+
+// ---------------------------------------------------------------------------
+// Mongo cluster encapsulation.
+//
+// A cluster enables the communication with one or more servers participating
+// in a mongo cluster. This works with individual servers, a replica set,
+// a replica pair, one or multiple mongos routers, etc.
+
+type mongoCluster struct {
+ sync.RWMutex
+ serverSynced sync.Cond
+ userSeeds []string
+ dynaSeeds []string
+ servers mongoServers
+ masters mongoServers
+ references int
+ syncing bool
+ syncCount uint
+ cachedIndex map[string]bool
+ sync chan bool
+ dial dialer
+ dialInfo *DialInfo
+}
+
+func newCluster(userSeeds []string, info *DialInfo) *mongoCluster {
+ cluster := &mongoCluster{
+ userSeeds: userSeeds,
+ references: 1,
+ dial: dialer{info.Dial, info.DialServer},
+ dialInfo: info,
+ }
+ cluster.serverSynced.L = cluster.RWMutex.RLocker()
+ cluster.sync = make(chan bool, 1)
+ stats.cluster(+1)
+ go cluster.syncServersLoop()
+ return cluster
+}
+
+// Acquire increases the reference count for the cluster.
+func (cluster *mongoCluster) Acquire() {
+ cluster.Lock()
+ cluster.references++
+ debugf("Cluster %p acquired (refs=%d)", cluster, cluster.references)
+ cluster.Unlock()
+}
+
+// Release decreases the reference count for the cluster. Once
+// it reaches zero, all servers will be closed.
+func (cluster *mongoCluster) Release() {
+ cluster.Lock()
+ if cluster.references == 0 {
+ panic("cluster.Release() with references == 0")
+ }
+ cluster.references--
+ debugf("Cluster %p released (refs=%d)", cluster, cluster.references)
+ if cluster.references == 0 {
+ for _, server := range cluster.servers.Slice() {
+ server.Close()
+ }
+ // Wake up the sync loop so it can die.
+ cluster.syncServers()
+ stats.cluster(-1)
+ }
+ cluster.Unlock()
+}
+
+func (cluster *mongoCluster) LiveServers() (servers []string) {
+ cluster.RLock()
+ for _, serv := range cluster.servers.Slice() {
+ servers = append(servers, serv.Addr)
+ }
+ cluster.RUnlock()
+ return servers
+}
+
+func (cluster *mongoCluster) removeServer(server *mongoServer) {
+ cluster.Lock()
+ cluster.masters.Remove(server)
+ other := cluster.servers.Remove(server)
+ cluster.Unlock()
+ if other != nil {
+ other.CloseIdle()
+ log("Removed server ", server.Addr, " from cluster.")
+ }
+ server.CloseIdle()
+}
+
+type isMasterResult struct {
+ IsMaster bool
+ Secondary bool
+ Primary string
+ Hosts []string
+ Passives []string
+ Tags bson.D
+ Msg string
+ SetName string `bson:"setName"`
+ MaxWireVersion int `bson:"maxWireVersion"`
+}
+
+func (cluster *mongoCluster) isMaster(socket *mongoSocket, result *isMasterResult) error {
+ // Monotonic let's it talk to a slave and still hold the socket.
+ session := newSession(Monotonic, cluster, cluster.dialInfo)
+ session.setSocket(socket)
+
+ var cmd = bson.D{{Name: "isMaster", Value: 1}}
+
+ // Send client metadata to the server to identify this socket if this is
+ // the first isMaster call only.
+ //
+ // isMaster commands issued after the initial connection handshake MUST NOT contain handshake arguments
+ // https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.rst#connection-handshake
+ //
+ socket.sendMeta.Do(func() {
+ var meta = bson.M{
+ "driver": bson.M{
+ "name": "mgo",
+ "version": "globalsign",
+ },
+ "os": bson.M{
+ "type": runtime.GOOS,
+ "architecture": runtime.GOARCH,
+ },
+ }
+
+ // Include the application name if set
+ if cluster.dialInfo.AppName != "" {
+ meta["application"] = bson.M{"name": cluster.dialInfo.AppName}
+ }
+
+ cmd = append(cmd, bson.DocElem{
+ Name: "client",
+ Value: meta,
+ })
+ })
+
+ err := session.runOnSocket(socket, cmd, result)
+ session.Close()
+ return err
+}
+
+type possibleTimeout interface {
+ Timeout() bool
+}
+
+func (cluster *mongoCluster) syncServer(server *mongoServer) (info *mongoServerInfo, hosts []string, err error) {
+ addr := server.Addr
+ log("SYNC Processing ", addr, "...")
+
+ // Retry a few times to avoid knocking a server down for a hiccup.
+ var result isMasterResult
+ var tryerr error
+ for retry := 0; ; retry++ {
+ if retry == 3 || retry == 1 && cluster.dialInfo.FailFast {
+ return nil, nil, tryerr
+ }
+ if retry > 0 {
+ // Don't abuse the server needlessly if there's something actually wrong.
+ if err, ok := tryerr.(possibleTimeout); ok && err.Timeout() {
+ // Give a chance for waiters to timeout as well.
+ cluster.serverSynced.Broadcast()
+ }
+ time.Sleep(syncShortDelay)
+ }
+
+ // Don't ever hit the pool limit for syncing
+ config := cluster.dialInfo.Copy()
+ config.PoolLimit = 0
+
+ socket, _, err := server.AcquireSocket(config)
+ if err != nil {
+ tryerr = err
+ logf("SYNC Failed to get socket to %s: %v", addr, err)
+ continue
+ }
+ err = cluster.isMaster(socket, &result)
+
+ // Restore the correct dial config before returning it to the pool
+ socket.dialInfo = cluster.dialInfo
+ socket.Release()
+
+ if err != nil {
+ tryerr = err
+ logf("SYNC Command 'ismaster' to %s failed: %v", addr, err)
+ continue
+ }
+ debugf("SYNC Result of 'ismaster' from %s: %#v", addr, result)
+ break
+ }
+
+ if cluster.dialInfo.ReplicaSetName != "" && result.SetName != cluster.dialInfo.ReplicaSetName {
+ logf("SYNC Server %s is not a member of replica set %q", addr, cluster.dialInfo.ReplicaSetName)
+ return nil, nil, fmt.Errorf("server %s is not a member of replica set %q", addr, cluster.dialInfo.ReplicaSetName)
+ }
+
+ if result.IsMaster {
+ debugf("SYNC %s is a master.", addr)
+ if !server.info.Master {
+ // Made an incorrect assumption above, so fix stats.
+ stats.conn(-1, false)
+ stats.conn(+1, true)
+ }
+ } else if result.Secondary {
+ debugf("SYNC %s is a slave.", addr)
+ } else if cluster.dialInfo.Direct {
+ logf("SYNC %s in unknown state. Pretending it's a slave due to direct connection.", addr)
+ } else {
+ logf("SYNC %s is neither a master nor a slave.", addr)
+ // Let stats track it as whatever was known before.
+ return nil, nil, errors.New(addr + " is not a master nor slave")
+ }
+
+ info = &mongoServerInfo{
+ Master: result.IsMaster,
+ Mongos: result.Msg == "isdbgrid",
+ Tags: result.Tags,
+ SetName: result.SetName,
+ MaxWireVersion: result.MaxWireVersion,
+ }
+
+ hosts = make([]string, 0, 1+len(result.Hosts)+len(result.Passives))
+ if result.Primary != "" {
+ // First in the list to speed up master discovery.
+ hosts = append(hosts, result.Primary)
+ }
+ hosts = append(hosts, result.Hosts...)
+ hosts = append(hosts, result.Passives...)
+
+ debugf("SYNC %s knows about the following peers: %#v", addr, hosts)
+ return info, hosts, nil
+}
+
+type syncKind bool
+
+const (
+ completeSync syncKind = true
+ partialSync syncKind = false
+)
+
+func (cluster *mongoCluster) addServer(server *mongoServer, info *mongoServerInfo, syncKind syncKind) {
+ cluster.Lock()
+ current := cluster.servers.Search(server.ResolvedAddr)
+ if current == nil {
+ if syncKind == partialSync {
+ cluster.Unlock()
+ server.Close()
+ log("SYNC Discarding unknown server ", server.Addr, " due to partial sync.")
+ return
+ }
+ cluster.servers.Add(server)
+ if info.Master {
+ cluster.masters.Add(server)
+ log("SYNC Adding ", server.Addr, " to cluster as a master.")
+ } else {
+ log("SYNC Adding ", server.Addr, " to cluster as a slave.")
+ }
+ } else {
+ if server != current {
+ panic("addServer attempting to add duplicated server")
+ }
+ if server.Info().Master != info.Master {
+ if info.Master {
+ log("SYNC Server ", server.Addr, " is now a master.")
+ cluster.masters.Add(server)
+ } else {
+ log("SYNC Server ", server.Addr, " is now a slave.")
+ cluster.masters.Remove(server)
+ }
+ }
+ }
+ server.SetInfo(info)
+ debugf("SYNC Broadcasting availability of server %s", server.Addr)
+ cluster.serverSynced.Broadcast()
+ cluster.Unlock()
+}
+
+func (cluster *mongoCluster) getKnownAddrs() []string {
+ cluster.RLock()
+ max := len(cluster.userSeeds) + len(cluster.dynaSeeds) + cluster.servers.Len()
+ seen := make(map[string]bool, max)
+ known := make([]string, 0, max)
+
+ add := func(addr string) {
+ if _, found := seen[addr]; !found {
+ seen[addr] = true
+ known = append(known, addr)
+ }
+ }
+
+ for _, addr := range cluster.userSeeds {
+ add(addr)
+ }
+ for _, addr := range cluster.dynaSeeds {
+ add(addr)
+ }
+ for _, serv := range cluster.servers.Slice() {
+ add(serv.Addr)
+ }
+ cluster.RUnlock()
+
+ return known
+}
+
+// syncServers injects a value into the cluster.sync channel to force
+// an iteration of the syncServersLoop function.
+func (cluster *mongoCluster) syncServers() {
+ select {
+ case cluster.sync <- true:
+ default:
+ }
+}
+
+// How long to wait for a checkup of the cluster topology if nothing
+// else kicks a synchronization before that.
+const syncServersDelay = 30 * time.Second
+const syncShortDelay = 500 * time.Millisecond
+
+// syncServersLoop loops while the cluster is alive to keep its idea of
+// the server topology up-to-date. It must be called just once from
+// newCluster. The loop iterates once syncServersDelay has passed, or
+// if somebody injects a value into the cluster.sync channel to force a
+// synchronization. A loop iteration will contact all servers in
+// parallel, ask them about known peers and their own role within the
+// cluster, and then attempt to do the same with all the peers
+// retrieved.
+func (cluster *mongoCluster) syncServersLoop() {
+ for {
+ debugf("SYNC Cluster %p is starting a sync loop iteration.", cluster)
+
+ cluster.Lock()
+ if cluster.references == 0 {
+ cluster.Unlock()
+ break
+ }
+ cluster.references++ // Keep alive while syncing.
+ direct := cluster.dialInfo.Direct
+ cluster.Unlock()
+
+ cluster.syncServersIteration(direct)
+
+ // We just synchronized, so consume any outstanding requests.
+ select {
+ case <-cluster.sync:
+ default:
+ }
+
+ cluster.Release()
+
+ // Hold off before allowing another sync. No point in
+ // burning CPU looking for down servers.
+ if !cluster.dialInfo.FailFast {
+ time.Sleep(syncShortDelay)
+ }
+
+ cluster.Lock()
+ if cluster.references == 0 {
+ cluster.Unlock()
+ break
+ }
+ cluster.syncCount++
+ // Poke all waiters so they have a chance to timeout or
+ // restart syncing if they wish to.
+ cluster.serverSynced.Broadcast()
+ // Check if we have to restart immediately either way.
+ restart := !direct && cluster.masters.Empty() || cluster.servers.Empty()
+ cluster.Unlock()
+
+ if restart {
+ log("SYNC No masters found. Will synchronize again.")
+ time.Sleep(syncShortDelay)
+ continue
+ }
+
+ debugf("SYNC Cluster %p waiting for next requested or scheduled sync.", cluster)
+
+ // Hold off until somebody explicitly requests a synchronization
+ // or it's time to check for a cluster topology change again.
+ select {
+ case <-cluster.sync:
+ case <-time.After(syncServersDelay):
+ }
+ }
+ debugf("SYNC Cluster %p is stopping its sync loop.", cluster)
+}
+
+func (cluster *mongoCluster) server(addr string, tcpaddr *net.TCPAddr) *mongoServer {
+ cluster.RLock()
+ server := cluster.servers.Search(tcpaddr.String())
+ cluster.RUnlock()
+ if server != nil {
+ return server
+ }
+ return newServer(addr, tcpaddr, cluster.sync, cluster.dial, cluster.dialInfo)
+}
+
+func resolveAddr(addr string) (*net.TCPAddr, error) {
+ // Simple cases that do not need actual resolution. Works with IPv4 and v6.
+ if host, port, err := net.SplitHostPort(addr); err == nil {
+ if port, _ := strconv.Atoi(port); port > 0 {
+ zone := ""
+ if i := strings.LastIndex(host, "%"); i >= 0 {
+ zone = host[i+1:]
+ host = host[:i]
+ }
+ ip := net.ParseIP(host)
+ if ip != nil {
+ return &net.TCPAddr{IP: ip, Port: port, Zone: zone}, nil
+ }
+ }
+ }
+
+ // Attempt to resolve IPv4 and v6 concurrently.
+ addrChan := make(chan *net.TCPAddr, 2)
+ for _, network := range []string{"udp4", "udp6"} {
+ network := network
+ go func() {
+ // The unfortunate UDP dialing hack allows having a timeout on address resolution.
+ conn, err := net.DialTimeout(network, addr, 10*time.Second)
+ if err != nil {
+ addrChan <- nil
+ } else {
+ addrChan <- (*net.TCPAddr)(conn.RemoteAddr().(*net.UDPAddr))
+ conn.Close()
+ }
+ }()
+ }
+
+ // Wait for the result of IPv4 and v6 resolution. Use IPv4 if available.
+ tcpaddr := <-addrChan
+ if tcpaddr == nil || len(tcpaddr.IP) != 4 {
+ var timeout <-chan time.Time
+ if tcpaddr != nil {
+ // Don't wait too long if an IPv6 address is known.
+ timeout = time.After(50 * time.Millisecond)
+ }
+ select {
+ case <-timeout:
+ case tcpaddr2 := <-addrChan:
+ if tcpaddr == nil || tcpaddr2 != nil {
+ // It's an IPv4 address or the only known address. Use it.
+ tcpaddr = tcpaddr2
+ }
+ }
+ }
+
+ if tcpaddr == nil {
+ log("SYNC Failed to resolve server address: ", addr)
+ return nil, errors.New("failed to resolve server address: " + addr)
+ }
+ if tcpaddr.String() != addr {
+ debug("SYNC Address ", addr, " resolved as ", tcpaddr.String())
+ }
+ return tcpaddr, nil
+}
+
+type pendingAdd struct {
+ server *mongoServer
+ info *mongoServerInfo
+}
+
+func (cluster *mongoCluster) syncServersIteration(direct bool) {
+ log("SYNC Starting full topology synchronization...")
+
+ var wg sync.WaitGroup
+ var m sync.Mutex
+ notYetAdded := make(map[string]pendingAdd)
+ addIfFound := make(map[string]bool)
+ seen := make(map[string]bool)
+ syncKind := partialSync
+
+ var spawnSync func(addr string, byMaster bool)
+ spawnSync = func(addr string, byMaster bool) {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+
+ tcpaddr, err := resolveAddr(addr)
+ if err != nil {
+ log("SYNC Failed to start sync of ", addr, ": ", err.Error())
+ return
+ }
+ resolvedAddr := tcpaddr.String()
+
+ m.Lock()
+ if byMaster {
+ if pending, ok := notYetAdded[resolvedAddr]; ok {
+ delete(notYetAdded, resolvedAddr)
+ m.Unlock()
+ cluster.addServer(pending.server, pending.info, completeSync)
+ return
+ }
+ addIfFound[resolvedAddr] = true
+ }
+ if seen[resolvedAddr] {
+ m.Unlock()
+ return
+ }
+ seen[resolvedAddr] = true
+ m.Unlock()
+
+ server := cluster.server(addr, tcpaddr)
+ info, hosts, err := cluster.syncServer(server)
+ if err != nil {
+ cluster.removeServer(server)
+ return
+ }
+
+ m.Lock()
+ add := direct || info.Master || addIfFound[resolvedAddr]
+ if add {
+ syncKind = completeSync
+ } else {
+ notYetAdded[resolvedAddr] = pendingAdd{server, info}
+ }
+ m.Unlock()
+ if add {
+ cluster.addServer(server, info, completeSync)
+ }
+ if !direct {
+ for _, addr := range hosts {
+ spawnSync(addr, info.Master)
+ }
+ }
+ }()
+ }
+
+ knownAddrs := cluster.getKnownAddrs()
+ for _, addr := range knownAddrs {
+ spawnSync(addr, false)
+ }
+ wg.Wait()
+
+ if syncKind == completeSync {
+ logf("SYNC Synchronization was complete (got data from primary).")
+ for _, pending := range notYetAdded {
+ cluster.removeServer(pending.server)
+ }
+ } else {
+ logf("SYNC Synchronization was partial (cannot talk to primary).")
+ for _, pending := range notYetAdded {
+ cluster.addServer(pending.server, pending.info, partialSync)
+ }
+ }
+
+ cluster.Lock()
+ mastersLen := cluster.masters.Len()
+ logf("SYNC Synchronization completed: %d master(s) and %d slave(s) alive.", mastersLen, cluster.servers.Len()-mastersLen)
+
+ // Update dynamic seeds, but only if we have any good servers. Otherwise,
+ // leave them alone for better chances of a successful sync in the future.
+ if syncKind == completeSync {
+ dynaSeeds := make([]string, cluster.servers.Len())
+ for i, server := range cluster.servers.Slice() {
+ dynaSeeds[i] = server.Addr
+ }
+ cluster.dynaSeeds = dynaSeeds
+ debugf("SYNC New dynamic seeds: %#v\n", dynaSeeds)
+ }
+ cluster.Unlock()
+}
+
+// AcquireSocketWithPoolTimeout returns a socket to a server in the cluster. If slaveOk is
+// true, it will attempt to return a socket to a slave server. If it is
+// false, the socket will necessarily be to a master server.
+func (cluster *mongoCluster) AcquireSocketWithPoolTimeout(mode Mode, slaveOk bool, syncTimeout time.Duration, serverTags []bson.D, info *DialInfo) (s *mongoSocket, err error) {
+ var started time.Time
+ var syncCount uint
+ for {
+ cluster.RLock()
+ for {
+ mastersLen := cluster.masters.Len()
+ slavesLen := cluster.servers.Len() - mastersLen
+ debugf("Cluster has %d known masters and %d known slaves.", mastersLen, slavesLen)
+ if mastersLen > 0 && !(slaveOk && mode == Secondary) || slavesLen > 0 && slaveOk {
+ break
+ }
+ if mastersLen > 0 && mode == Secondary && cluster.masters.HasMongos() {
+ break
+ }
+ if started.IsZero() {
+ // Initialize after fast path above.
+ started = time.Now()
+ syncCount = cluster.syncCount
+ } else if syncTimeout != 0 && started.Before(time.Now().Add(-syncTimeout)) || cluster.dialInfo.FailFast && cluster.syncCount != syncCount {
+ cluster.RUnlock()
+ return nil, errors.New("no reachable servers")
+ }
+ log("Waiting for servers to synchronize...")
+ cluster.syncServers()
+
+ // Remember: this will release and reacquire the lock.
+ cluster.serverSynced.Wait()
+ }
+
+ var server *mongoServer
+ if slaveOk {
+ server = cluster.servers.BestFit(mode, serverTags)
+ } else {
+ server = cluster.masters.BestFit(mode, nil)
+ }
+ cluster.RUnlock()
+
+ if server == nil {
+ // Must have failed the requested tags. Sleep to avoid spinning.
+ time.Sleep(1e8)
+ continue
+ }
+
+ s, abended, err := server.AcquireSocketWithBlocking(info)
+ if err == errPoolTimeout {
+ // No need to remove servers from the topology if acquiring a socket fails for this reason.
+ return nil, err
+ }
+ if err != nil {
+ cluster.removeServer(server)
+ cluster.syncServers()
+ continue
+ }
+ if abended && !slaveOk {
+ var result isMasterResult
+ err := cluster.isMaster(s, &result)
+ if err != nil || !result.IsMaster {
+ logf("Cannot confirm server %s as master (%v)", server.Addr, err)
+ s.Release()
+ cluster.syncServers()
+ time.Sleep(100 * time.Millisecond)
+ continue
+ } else {
+ // We've managed to successfully reconnect to the master, we are no longer abnormaly ended
+ server.Lock()
+ server.abended = false
+ server.Unlock()
+ }
+ }
+ return s, nil
+ }
+}
+
+func (cluster *mongoCluster) CacheIndex(cacheKey string, exists bool) {
+ cluster.Lock()
+ if cluster.cachedIndex == nil {
+ cluster.cachedIndex = make(map[string]bool)
+ }
+ if exists {
+ cluster.cachedIndex[cacheKey] = true
+ } else {
+ delete(cluster.cachedIndex, cacheKey)
+ }
+ cluster.Unlock()
+}
+
+func (cluster *mongoCluster) HasCachedIndex(cacheKey string) (result bool) {
+ cluster.RLock()
+ if cluster.cachedIndex != nil {
+ result = cluster.cachedIndex[cacheKey]
+ }
+ cluster.RUnlock()
+ return
+}
+
+func (cluster *mongoCluster) ResetIndexCache() {
+ cluster.Lock()
+ cluster.cachedIndex = make(map[string]bool)
+ cluster.Unlock()
+}
diff --git a/vendor/github.com/globalsign/mgo/coarse_time.go b/vendor/github.com/globalsign/mgo/coarse_time.go
new file mode 100644
index 0000000000..e54dd17cf9
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/coarse_time.go
@@ -0,0 +1,62 @@
+package mgo
+
+import (
+ "sync"
+ "sync/atomic"
+ "time"
+)
+
+// coarseTimeProvider provides a periodically updated (approximate) time value to
+// amortise the cost of frequent calls to time.Now.
+//
+// A read throughput increase of ~6% was measured when using coarseTimeProvider with the
+// high-precision event timer (HPET) on FreeBSD 11.1 and Go 1.10.1 after merging
+// #116.
+//
+// Calling Now returns a time.Time that is updated at the configured interval,
+// however due to scheduling the value may be marginally older than expected.
+//
+// coarseTimeProvider is safe for concurrent use.
+type coarseTimeProvider struct {
+ once sync.Once
+ stop chan struct{}
+ last atomic.Value
+}
+
+// Now returns the most recently acquired time.Time value.
+func (t *coarseTimeProvider) Now() time.Time {
+ return t.last.Load().(time.Time)
+}
+
+// Close stops the periodic update of t.
+//
+// Any subsequent calls to Now will return the same value forever.
+func (t *coarseTimeProvider) Close() {
+ t.once.Do(func() {
+ close(t.stop)
+ })
+}
+
+// newcoarseTimeProvider returns a coarseTimeProvider configured to update at granularity.
+func newcoarseTimeProvider(granularity time.Duration) *coarseTimeProvider {
+ t := &coarseTimeProvider{
+ stop: make(chan struct{}),
+ }
+
+ t.last.Store(time.Now())
+
+ go func() {
+ ticker := time.NewTicker(granularity)
+ for {
+ select {
+ case <-t.stop:
+ ticker.Stop()
+ return
+ case <-ticker.C:
+ t.last.Store(time.Now())
+ }
+ }
+ }()
+
+ return t
+}
diff --git a/vendor/github.com/globalsign/mgo/doc.go b/vendor/github.com/globalsign/mgo/doc.go
new file mode 100644
index 0000000000..f3f373bf4f
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/doc.go
@@ -0,0 +1,35 @@
+// Package mgo (pronounced as "mango") offers a rich MongoDB driver for Go.
+//
+// Detailed documentation of the API is available at GoDoc:
+//
+// https://godoc.org/github.com/globalsign/mgo
+//
+// Usage of the driver revolves around the concept of sessions. To
+// get started, obtain a session using the Dial function:
+//
+// session, err := mgo.Dial(url)
+//
+// This will establish one or more connections with the cluster of
+// servers defined by the url parameter. From then on, the cluster
+// may be queried with multiple consistency rules (see SetMode) and
+// documents retrieved with statements such as:
+//
+// c := session.DB(database).C(collection)
+// err := c.Find(query).One(&result)
+//
+// New sessions are typically created by calling session.Copy on the
+// initial session obtained at dial time. These new sessions will share
+// the same cluster information and connection pool, and may be easily
+// handed into other methods and functions for organizing logic.
+// Every session created must have its Close method called at the end
+// of its life time, so its resources may be put back in the pool or
+// collected, depending on the case.
+//
+// There is a sub-package that provides support for BSON, which can be
+// used by itself as well:
+//
+// https://godoc.org/github.com/globalsign/mgo/bson
+//
+// For more details, see the documentation for the types and methods.
+//
+package mgo
diff --git a/vendor/github.com/globalsign/mgo/gridfs.go b/vendor/github.com/globalsign/mgo/gridfs.go
new file mode 100644
index 0000000000..0954b166b9
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/gridfs.go
@@ -0,0 +1,782 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package mgo
+
+import (
+ "crypto/md5"
+ "encoding/hex"
+ "errors"
+ "hash"
+ "io"
+ "os"
+ "sync"
+ "time"
+
+ "github.com/globalsign/mgo/bson"
+)
+
+// GridFS stores files in two collections:
+//
+// - chunks stores the binary chunks. For details, see the chunks Collection.
+// - files stores the file’s metadata. For details, see the files Collection.
+//
+// GridFS places the collections in a common bucket by prefixing each with the bucket name.
+// By default, GridFS uses two collections with a bucket named fs:
+//
+// - fs.files
+// - fs.chunks
+//
+// You can choose a different bucket name, as well as create multiple buckets in a single database.
+// The full collection name, which includes the bucket name, is subject to the namespace length limit.
+//
+// Relevant documentation:
+//
+// https://docs.mongodb.com/manual/core/gridfs/
+// https://docs.mongodb.com/manual/core/gridfs/#gridfs-chunks-collection
+// https://docs.mongodb.com/manual/core/gridfs/#gridfs-files-collection
+//
+type GridFS struct {
+ Files *Collection
+ Chunks *Collection
+}
+
+type gfsFileMode int
+
+const (
+ gfsClosed gfsFileMode = 0
+ gfsReading gfsFileMode = 1
+ gfsWriting gfsFileMode = 2
+)
+
+// GridFile document in files collection
+type GridFile struct {
+ m sync.Mutex
+ c sync.Cond
+ gfs *GridFS
+ mode gfsFileMode
+ err error
+
+ chunk int
+ offset int64
+
+ wpending int
+ wbuf []byte
+ wsum hash.Hash
+
+ rbuf []byte
+ rcache *gfsCachedChunk
+
+ doc gfsFile
+}
+
+type gfsFile struct {
+ Id interface{} `bson:"_id"`
+ ChunkSize int `bson:"chunkSize"`
+ UploadDate time.Time `bson:"uploadDate"`
+ Length int64 `bson:",minsize"`
+ MD5 string
+ Filename string `bson:",omitempty"`
+ ContentType string `bson:"contentType,omitempty"`
+ Metadata *bson.Raw `bson:",omitempty"`
+}
+
+type gfsChunk struct {
+ Id interface{} `bson:"_id"`
+ FilesId interface{} `bson:"files_id"`
+ N int
+ Data []byte
+}
+
+type gfsCachedChunk struct {
+ wait sync.Mutex
+ n int
+ data []byte
+ err error
+}
+
+func newGridFS(db *Database, prefix string) *GridFS {
+ return &GridFS{db.C(prefix + ".files"), db.C(prefix + ".chunks")}
+}
+
+func (gfs *GridFS) newFile() *GridFile {
+ file := &GridFile{gfs: gfs}
+ file.c.L = &file.m
+ //runtime.SetFinalizer(file, finalizeFile)
+ return file
+}
+
+func finalizeFile(file *GridFile) {
+ file.Close()
+}
+
+// Create creates a new file with the provided name in the GridFS. If the file
+// name already exists, a new version will be inserted with an up-to-date
+// uploadDate that will cause it to be atomically visible to the Open and
+// OpenId methods. If the file name is not important, an empty name may be
+// provided and the file Id used instead.
+//
+// It's important to Close files whether they are being written to
+// or read from, and to check the err result to ensure the operation
+// completed successfully.
+//
+// A simple example inserting a new file:
+//
+// func check(err error) {
+// if err != nil {
+// panic(err.String())
+// }
+// }
+// file, err := db.GridFS("fs").Create("myfile.txt")
+// check(err)
+// n, err := file.Write([]byte("Hello world!"))
+// check(err)
+// err = file.Close()
+// check(err)
+// fmt.Printf("%d bytes written\n", n)
+//
+// The io.Writer interface is implemented by *GridFile and may be used to
+// help on the file creation. For example:
+//
+// file, err := db.GridFS("fs").Create("myfile.txt")
+// check(err)
+// messages, err := os.Open("/var/log/messages")
+// check(err)
+// defer messages.Close()
+// err = io.Copy(file, messages)
+// check(err)
+// err = file.Close()
+// check(err)
+//
+func (gfs *GridFS) Create(name string) (file *GridFile, err error) {
+ file = gfs.newFile()
+ file.mode = gfsWriting
+ file.wsum = md5.New()
+ file.doc = gfsFile{Id: bson.NewObjectId(), ChunkSize: 255 * 1024, Filename: name}
+ return
+}
+
+// OpenId returns the file with the provided id, for reading.
+// If the file isn't found, err will be set to mgo.ErrNotFound.
+//
+// It's important to Close files whether they are being written to
+// or read from, and to check the err result to ensure the operation
+// completed successfully.
+//
+// The following example will print the first 8192 bytes from the file:
+//
+// func check(err error) {
+// if err != nil {
+// panic(err.String())
+// }
+// }
+// file, err := db.GridFS("fs").OpenId(objid)
+// check(err)
+// b := make([]byte, 8192)
+// n, err := file.Read(b)
+// check(err)
+// fmt.Println(string(b))
+// check(err)
+// err = file.Close()
+// check(err)
+// fmt.Printf("%d bytes read\n", n)
+//
+// The io.Reader interface is implemented by *GridFile and may be used to
+// deal with it. As an example, the following snippet will dump the whole
+// file into the standard output:
+//
+// file, err := db.GridFS("fs").OpenId(objid)
+// check(err)
+// err = io.Copy(os.Stdout, file)
+// check(err)
+// err = file.Close()
+// check(err)
+//
+func (gfs *GridFS) OpenId(id interface{}) (file *GridFile, err error) {
+ var doc gfsFile
+ err = gfs.Files.Find(bson.M{"_id": id}).One(&doc)
+ if err != nil {
+ return
+ }
+ file = gfs.newFile()
+ file.mode = gfsReading
+ file.doc = doc
+ return
+}
+
+// Open returns the most recently uploaded file with the provided
+// name, for reading. If the file isn't found, err will be set
+// to mgo.ErrNotFound.
+//
+// It's important to Close files whether they are being written to
+// or read from, and to check the err result to ensure the operation
+// completed successfully.
+//
+// The following example will print the first 8192 bytes from the file:
+//
+// file, err := db.GridFS("fs").Open("myfile.txt")
+// check(err)
+// b := make([]byte, 8192)
+// n, err := file.Read(b)
+// check(err)
+// fmt.Println(string(b))
+// check(err)
+// err = file.Close()
+// check(err)
+// fmt.Printf("%d bytes read\n", n)
+//
+// The io.Reader interface is implemented by *GridFile and may be used to
+// deal with it. As an example, the following snippet will dump the whole
+// file into the standard output:
+//
+// file, err := db.GridFS("fs").Open("myfile.txt")
+// check(err)
+// err = io.Copy(os.Stdout, file)
+// check(err)
+// err = file.Close()
+// check(err)
+//
+func (gfs *GridFS) Open(name string) (file *GridFile, err error) {
+ var doc gfsFile
+ err = gfs.Files.Find(bson.M{"filename": name}).Sort("-uploadDate").One(&doc)
+ if err != nil {
+ return
+ }
+ file = gfs.newFile()
+ file.mode = gfsReading
+ file.doc = doc
+ return
+}
+
+// OpenNext opens the next file from iter for reading, sets *file to it,
+// and returns true on the success case. If no more documents are available
+// on iter or an error occurred, *file is set to nil and the result is false.
+// Errors will be available via iter.Err().
+//
+// The iter parameter must be an iterator on the GridFS files collection.
+// Using the GridFS.Find method is an easy way to obtain such an iterator,
+// but any iterator on the collection will work.
+//
+// If the provided *file is non-nil, OpenNext will close it before attempting
+// to iterate to the next element. This means that in a loop one only
+// has to worry about closing files when breaking out of the loop early
+// (break, return, or panic).
+//
+// For example:
+//
+// gfs := db.GridFS("fs")
+// query := gfs.Find(nil).Sort("filename")
+// iter := query.Iter()
+// var f *mgo.GridFile
+// for gfs.OpenNext(iter, &f) {
+// fmt.Printf("Filename: %s\n", f.Name())
+// }
+// if iter.Close() != nil {
+// panic(iter.Close())
+// }
+//
+func (gfs *GridFS) OpenNext(iter *Iter, file **GridFile) bool {
+ if *file != nil {
+ // Ignoring the error here shouldn't be a big deal
+ // as we're reading the file and the loop iteration
+ // for this file is finished.
+ _ = (*file).Close()
+ }
+ var doc gfsFile
+ if !iter.Next(&doc) {
+ *file = nil
+ return false
+ }
+ f := gfs.newFile()
+ f.mode = gfsReading
+ f.doc = doc
+ *file = f
+ return true
+}
+
+// Find runs query on GridFS's files collection and returns
+// the resulting Query.
+//
+// This logic:
+//
+// gfs := db.GridFS("fs")
+// iter := gfs.Find(nil).Iter()
+//
+// Is equivalent to:
+//
+// files := db.C("fs" + ".files")
+// iter := files.Find(nil).Iter()
+//
+func (gfs *GridFS) Find(query interface{}) *Query {
+ return gfs.Files.Find(query)
+}
+
+// RemoveId deletes the file with the provided id from the GridFS.
+func (gfs *GridFS) RemoveId(id interface{}) error {
+ err := gfs.Files.Remove(bson.M{"_id": id})
+ if err != nil {
+ return err
+ }
+ _, err = gfs.Chunks.RemoveAll(bson.D{{Name: "files_id", Value: id}})
+ return err
+}
+
+type gfsDocId struct {
+ Id interface{} `bson:"_id"`
+}
+
+// Remove deletes all files with the provided name from the GridFS.
+func (gfs *GridFS) Remove(name string) (err error) {
+ iter := gfs.Files.Find(bson.M{"filename": name}).Select(bson.M{"_id": 1}).Iter()
+ var doc gfsDocId
+ for iter.Next(&doc) {
+ if e := gfs.RemoveId(doc.Id); e != nil {
+ err = e
+ }
+ }
+ if err == nil {
+ err = iter.Close()
+ }
+ return err
+}
+
+func (file *GridFile) assertMode(mode gfsFileMode) {
+ switch file.mode {
+ case mode:
+ return
+ case gfsWriting:
+ panic("GridFile is open for writing")
+ case gfsReading:
+ panic("GridFile is open for reading")
+ case gfsClosed:
+ panic("GridFile is closed")
+ default:
+ panic("internal error: missing GridFile mode")
+ }
+}
+
+// SetChunkSize sets size of saved chunks. Once the file is written to, it
+// will be split in blocks of that size and each block saved into an
+// independent chunk document. The default chunk size is 255kb.
+//
+// It is a runtime error to call this function once the file has started
+// being written to.
+func (file *GridFile) SetChunkSize(bytes int) {
+ file.assertMode(gfsWriting)
+ debugf("GridFile %p: setting chunk size to %d", file, bytes)
+ file.m.Lock()
+ file.doc.ChunkSize = bytes
+ file.m.Unlock()
+}
+
+// Id returns the current file Id.
+func (file *GridFile) Id() interface{} {
+ return file.doc.Id
+}
+
+// SetId changes the current file Id.
+//
+// It is a runtime error to call this function once the file has started
+// being written to, or when the file is not open for writing.
+func (file *GridFile) SetId(id interface{}) {
+ file.assertMode(gfsWriting)
+ file.m.Lock()
+ file.doc.Id = id
+ file.m.Unlock()
+}
+
+// Name returns the optional file name. An empty string will be returned
+// in case it is unset.
+func (file *GridFile) Name() string {
+ return file.doc.Filename
+}
+
+// SetName changes the optional file name. An empty string may be used to
+// unset it.
+//
+// It is a runtime error to call this function when the file is not open
+// for writing.
+func (file *GridFile) SetName(name string) {
+ file.assertMode(gfsWriting)
+ file.m.Lock()
+ file.doc.Filename = name
+ file.m.Unlock()
+}
+
+// ContentType returns the optional file content type. An empty string will be
+// returned in case it is unset.
+func (file *GridFile) ContentType() string {
+ return file.doc.ContentType
+}
+
+// SetContentType changes the optional file content type. An empty string may be
+// used to unset it.
+//
+// It is a runtime error to call this function when the file is not open
+// for writing.
+func (file *GridFile) SetContentType(ctype string) {
+ file.assertMode(gfsWriting)
+ file.m.Lock()
+ file.doc.ContentType = ctype
+ file.m.Unlock()
+}
+
+// GetMeta unmarshals the optional "metadata" field associated with the
+// file into the result parameter. The meaning of keys under that field
+// is user-defined. For example:
+//
+// result := struct{ INode int }{}
+// err = file.GetMeta(&result)
+// if err != nil {
+// panic(err.String())
+// }
+// fmt.Printf("inode: %d\n", result.INode)
+//
+func (file *GridFile) GetMeta(result interface{}) (err error) {
+ file.m.Lock()
+ if file.doc.Metadata != nil {
+ err = bson.Unmarshal(file.doc.Metadata.Data, result)
+ }
+ file.m.Unlock()
+ return
+}
+
+// SetMeta changes the optional "metadata" field associated with the
+// file. The meaning of keys under that field is user-defined.
+// For example:
+//
+// file.SetMeta(bson.M{"inode": inode})
+//
+// It is a runtime error to call this function when the file is not open
+// for writing.
+func (file *GridFile) SetMeta(metadata interface{}) {
+ file.assertMode(gfsWriting)
+ data, err := bson.Marshal(metadata)
+ file.m.Lock()
+ if err != nil && file.err == nil {
+ file.err = err
+ } else {
+ file.doc.Metadata = &bson.Raw{Data: data}
+ }
+ file.m.Unlock()
+}
+
+// Size returns the file size in bytes.
+func (file *GridFile) Size() (bytes int64) {
+ file.m.Lock()
+ bytes = file.doc.Length
+ file.m.Unlock()
+ return
+}
+
+// MD5 returns the file MD5 as a hex-encoded string.
+func (file *GridFile) MD5() (md5 string) {
+ return file.doc.MD5
+}
+
+// UploadDate returns the file upload time.
+func (file *GridFile) UploadDate() time.Time {
+ return file.doc.UploadDate
+}
+
+// SetUploadDate changes the file upload time.
+//
+// It is a runtime error to call this function when the file is not open
+// for writing.
+func (file *GridFile) SetUploadDate(t time.Time) {
+ file.assertMode(gfsWriting)
+ file.m.Lock()
+ file.doc.UploadDate = t
+ file.m.Unlock()
+}
+
+// Close flushes any pending changes in case the file is being written
+// to, waits for any background operations to finish, and closes the file.
+//
+// It's important to Close files whether they are being written to
+// or read from, and to check the err result to ensure the operation
+// completed successfully.
+func (file *GridFile) Close() (err error) {
+ file.m.Lock()
+ defer file.m.Unlock()
+ if file.mode == gfsWriting {
+ if len(file.wbuf) > 0 && file.err == nil {
+ file.insertChunk(file.wbuf)
+ file.wbuf = file.wbuf[0:0]
+ }
+ file.completeWrite()
+ } else if file.mode == gfsReading && file.rcache != nil {
+ file.rcache.wait.Lock()
+ file.rcache = nil
+ }
+ file.mode = gfsClosed
+ debugf("GridFile %p: closed", file)
+ return file.err
+}
+
+func (file *GridFile) completeWrite() {
+ for file.wpending > 0 {
+ debugf("GridFile %p: waiting for %d pending chunks to complete file write", file, file.wpending)
+ file.c.Wait()
+ }
+ if file.err == nil {
+ hexsum := hex.EncodeToString(file.wsum.Sum(nil))
+ if file.doc.UploadDate.IsZero() {
+ file.doc.UploadDate = bson.Now()
+ }
+ file.doc.MD5 = hexsum
+ file.err = file.gfs.Files.Insert(file.doc)
+ }
+ if file.err != nil {
+ file.gfs.Chunks.RemoveAll(bson.D{{Name: "files_id", Value: file.doc.Id}})
+ }
+ if file.err == nil {
+ index := Index{
+ Key: []string{"files_id", "n"},
+ Unique: true,
+ }
+ file.err = file.gfs.Chunks.EnsureIndex(index)
+ }
+}
+
+// Abort cancels an in-progress write, preventing the file from being
+// automically created and ensuring previously written chunks are
+// removed when the file is closed.
+//
+// It is a runtime error to call Abort when the file was not opened
+// for writing.
+func (file *GridFile) Abort() {
+ if file.mode != gfsWriting {
+ panic("file.Abort must be called on file opened for writing")
+ }
+ file.err = errors.New("write aborted")
+}
+
+// Write writes the provided data to the file and returns the
+// number of bytes written and an error in case something
+// wrong happened.
+//
+// The file will internally cache the data so that all but the last
+// chunk sent to the database have the size defined by SetChunkSize.
+// This also means that errors may be deferred until a future call
+// to Write or Close.
+//
+// The parameters and behavior of this function turn the file
+// into an io.Writer.
+func (file *GridFile) Write(data []byte) (n int, err error) {
+ file.assertMode(gfsWriting)
+ file.m.Lock()
+ debugf("GridFile %p: writing %d bytes", file, len(data))
+ defer file.m.Unlock()
+
+ if file.err != nil {
+ return 0, file.err
+ }
+
+ n = len(data)
+ file.doc.Length += int64(n)
+ chunkSize := file.doc.ChunkSize
+
+ if len(file.wbuf)+len(data) < chunkSize {
+ file.wbuf = append(file.wbuf, data...)
+ return
+ }
+
+ // First, flush file.wbuf complementing with data.
+ if len(file.wbuf) > 0 {
+ missing := chunkSize - len(file.wbuf)
+ if missing > len(data) {
+ missing = len(data)
+ }
+ file.wbuf = append(file.wbuf, data[:missing]...)
+ data = data[missing:]
+ file.insertChunk(file.wbuf)
+ file.wbuf = file.wbuf[0:0]
+ }
+
+ // Then, flush all chunks from data without copying.
+ for len(data) > chunkSize {
+ size := chunkSize
+ if size > len(data) {
+ size = len(data)
+ }
+ file.insertChunk(data[:size])
+ data = data[size:]
+ }
+
+ // And append the rest for a future call.
+ file.wbuf = append(file.wbuf, data...)
+
+ return n, file.err
+}
+
+func (file *GridFile) insertChunk(data []byte) {
+ n := file.chunk
+ file.chunk++
+ debugf("GridFile %p: adding to checksum: %q", file, string(data))
+ file.wsum.Write(data)
+
+ for file.doc.ChunkSize*file.wpending >= 1024*1024 {
+ // Hold on.. we got a MB pending.
+ file.c.Wait()
+ if file.err != nil {
+ return
+ }
+ }
+
+ file.wpending++
+
+ debugf("GridFile %p: inserting chunk %d with %d bytes", file, n, len(data))
+
+ // We may not own the memory of data, so rather than
+ // simply copying it, we'll marshal the document ahead of time.
+ data, err := bson.Marshal(gfsChunk{bson.NewObjectId(), file.doc.Id, n, data})
+ if err != nil {
+ file.err = err
+ return
+ }
+
+ go func() {
+ err := file.gfs.Chunks.Insert(bson.Raw{Data: data})
+ file.m.Lock()
+ file.wpending--
+ if err != nil && file.err == nil {
+ file.err = err
+ }
+ file.c.Broadcast()
+ file.m.Unlock()
+ }()
+}
+
+// Seek sets the offset for the next Read or Write on file to
+// offset, interpreted according to whence: 0 means relative to
+// the origin of the file, 1 means relative to the current offset,
+// and 2 means relative to the end. It returns the new offset and
+// an error, if any.
+func (file *GridFile) Seek(offset int64, whence int) (pos int64, err error) {
+ file.m.Lock()
+ debugf("GridFile %p: seeking for %s (whence=%d)", file, offset, whence)
+ defer file.m.Unlock()
+ switch whence {
+ case os.SEEK_SET:
+ case os.SEEK_CUR:
+ offset += file.offset
+ case os.SEEK_END:
+ offset += file.doc.Length
+ default:
+ panic("unsupported whence value")
+ }
+ if offset > file.doc.Length {
+ return file.offset, errors.New("seek past end of file")
+ }
+ if offset == file.doc.Length {
+ // If we're seeking to the end of the file,
+ // no need to read anything. This enables
+ // a client to find the size of the file using only the
+ // io.ReadSeeker interface with low overhead.
+ file.offset = offset
+ return file.offset, nil
+ }
+ chunk := int(offset / int64(file.doc.ChunkSize))
+ if chunk+1 == file.chunk && offset >= file.offset {
+ file.rbuf = file.rbuf[int(offset-file.offset):]
+ file.offset = offset
+ return file.offset, nil
+ }
+ file.offset = offset
+ file.chunk = chunk
+ file.rbuf = nil
+ file.rbuf, err = file.getChunk()
+ if err == nil {
+ file.rbuf = file.rbuf[int(file.offset-int64(chunk)*int64(file.doc.ChunkSize)):]
+ }
+ return file.offset, err
+}
+
+// Read reads into b the next available data from the file and
+// returns the number of bytes written and an error in case
+// something wrong happened. At the end of the file, n will
+// be zero and err will be set to io.EOF.
+//
+// The parameters and behavior of this function turn the file
+// into an io.Reader.
+func (file *GridFile) Read(b []byte) (n int, err error) {
+ file.assertMode(gfsReading)
+ file.m.Lock()
+ debugf("GridFile %p: reading at offset %d into buffer of length %d", file, file.offset, len(b))
+ defer file.m.Unlock()
+ if file.offset == file.doc.Length {
+ return 0, io.EOF
+ }
+ for err == nil {
+ i := copy(b, file.rbuf)
+ n += i
+ file.offset += int64(i)
+ file.rbuf = file.rbuf[i:]
+ if i == len(b) || file.offset == file.doc.Length {
+ break
+ }
+ b = b[i:]
+ file.rbuf, err = file.getChunk()
+ }
+ return n, err
+}
+
+func (file *GridFile) getChunk() (data []byte, err error) {
+ cache := file.rcache
+ file.rcache = nil
+ if cache != nil && cache.n == file.chunk {
+ debugf("GridFile %p: Getting chunk %d from cache", file, file.chunk)
+ cache.wait.Lock()
+ data, err = cache.data, cache.err
+ } else {
+ debugf("GridFile %p: Fetching chunk %d", file, file.chunk)
+ var doc gfsChunk
+ err = file.gfs.Chunks.Find(bson.D{{Name: "files_id", Value: file.doc.Id}, {Name: "n", Value: file.chunk}}).One(&doc)
+ data = doc.Data
+ }
+ file.chunk++
+ if int64(file.chunk)*int64(file.doc.ChunkSize) < file.doc.Length {
+ // Read the next one in background.
+ cache = &gfsCachedChunk{n: file.chunk}
+ cache.wait.Lock()
+ debugf("GridFile %p: Scheduling chunk %d for background caching", file, file.chunk)
+ // Clone the session to avoid having it closed in between.
+ chunks := file.gfs.Chunks
+ session := chunks.Database.Session.Clone()
+ go func(id interface{}, n int) {
+ defer session.Close()
+ chunks = chunks.With(session)
+ var doc gfsChunk
+ cache.err = chunks.Find(bson.D{{Name: "files_id", Value: id}, {Name: "n", Value: n}}).One(&doc)
+ cache.data = doc.Data
+ cache.wait.Unlock()
+ }(file.doc.Id, file.chunk)
+ file.rcache = cache
+ }
+ debugf("Returning err: %#v", err)
+ return
+}
diff --git a/vendor/github.com/globalsign/mgo/internal/json/LICENSE b/vendor/github.com/globalsign/mgo/internal/json/LICENSE
new file mode 100644
index 0000000000..7448756763
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/internal/json/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/globalsign/mgo/internal/json/decode.go b/vendor/github.com/globalsign/mgo/internal/json/decode.go
new file mode 100644
index 0000000000..d5ca1f9a85
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/internal/json/decode.go
@@ -0,0 +1,1685 @@
+// Copyright 2010 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.
+
+// Represents JSON data structure using native Go types: booleans, floats,
+// strings, arrays, and maps.
+
+package json
+
+import (
+ "bytes"
+ "encoding"
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "reflect"
+ "runtime"
+ "strconv"
+ "unicode"
+ "unicode/utf16"
+ "unicode/utf8"
+)
+
+// Unmarshal parses the JSON-encoded data and stores the result
+// in the value pointed to by v.
+//
+// Unmarshal uses the inverse of the encodings that
+// Marshal uses, allocating maps, slices, and pointers as necessary,
+// with the following additional rules:
+//
+// To unmarshal JSON into a pointer, Unmarshal first handles the case of
+// the JSON being the JSON literal null. In that case, Unmarshal sets
+// the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into
+// the value pointed at by the pointer. If the pointer is nil, Unmarshal
+// allocates a new value for it to point to.
+//
+// To unmarshal JSON into a struct, Unmarshal matches incoming object
+// keys to the keys used by Marshal (either the struct field name or its tag),
+// preferring an exact match but also accepting a case-insensitive match.
+// Unmarshal will only set exported fields of the struct.
+//
+// To unmarshal JSON into an interface value,
+// Unmarshal stores one of these in the interface value:
+//
+// bool, for JSON booleans
+// float64, for JSON numbers
+// string, for JSON strings
+// []interface{}, for JSON arrays
+// map[string]interface{}, for JSON objects
+// nil for JSON null
+//
+// To unmarshal a JSON array into a slice, Unmarshal resets the slice length
+// to zero and then appends each element to the slice.
+// As a special case, to unmarshal an empty JSON array into a slice,
+// Unmarshal replaces the slice with a new empty slice.
+//
+// To unmarshal a JSON array into a Go array, Unmarshal decodes
+// JSON array elements into corresponding Go array elements.
+// If the Go array is smaller than the JSON array,
+// the additional JSON array elements are discarded.
+// If the JSON array is smaller than the Go array,
+// the additional Go array elements are set to zero values.
+//
+// To unmarshal a JSON object into a map, Unmarshal first establishes a map to
+// use, If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal
+// reuses the existing map, keeping existing entries. Unmarshal then stores key-
+// value pairs from the JSON object into the map. The map's key type must
+// either be a string or implement encoding.TextUnmarshaler.
+//
+// If a JSON value is not appropriate for a given target type,
+// or if a JSON number overflows the target type, Unmarshal
+// skips that field and completes the unmarshaling as best it can.
+// If no more serious errors are encountered, Unmarshal returns
+// an UnmarshalTypeError describing the earliest such error.
+//
+// The JSON null value unmarshals into an interface, map, pointer, or slice
+// by setting that Go value to nil. Because null is often used in JSON to mean
+// ``not present,'' unmarshaling a JSON null into any other Go type has no effect
+// on the value and produces no error.
+//
+// When unmarshaling quoted strings, invalid UTF-8 or
+// invalid UTF-16 surrogate pairs are not treated as an error.
+// Instead, they are replaced by the Unicode replacement
+// character U+FFFD.
+//
+func Unmarshal(data []byte, v interface{}) error {
+ // Check for well-formedness.
+ // Avoids filling out half a data structure
+ // before discovering a JSON syntax error.
+ var d decodeState
+ err := checkValid(data, &d.scan)
+ if err != nil {
+ return err
+ }
+
+ d.init(data)
+ return d.unmarshal(v)
+}
+
+// Unmarshaler is the interface implemented by types
+// that can unmarshal a JSON description of themselves.
+// The input can be assumed to be a valid encoding of
+// a JSON value. UnmarshalJSON must copy the JSON data
+// if it wishes to retain the data after returning.
+type Unmarshaler interface {
+ UnmarshalJSON([]byte) error
+}
+
+// An UnmarshalTypeError describes a JSON value that was
+// not appropriate for a value of a specific Go type.
+type UnmarshalTypeError struct {
+ Value string // description of JSON value - "bool", "array", "number -5"
+ Type reflect.Type // type of Go value it could not be assigned to
+ Offset int64 // error occurred after reading Offset bytes
+}
+
+func (e *UnmarshalTypeError) Error() string {
+ return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
+}
+
+// An UnmarshalFieldError describes a JSON object key that
+// led to an unexported (and therefore unwritable) struct field.
+// (No longer used; kept for compatibility.)
+type UnmarshalFieldError struct {
+ Key string
+ Type reflect.Type
+ Field reflect.StructField
+}
+
+func (e *UnmarshalFieldError) Error() string {
+ return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String()
+}
+
+// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
+// (The argument to Unmarshal must be a non-nil pointer.)
+type InvalidUnmarshalError struct {
+ Type reflect.Type
+}
+
+func (e *InvalidUnmarshalError) Error() string {
+ if e.Type == nil {
+ return "json: Unmarshal(nil)"
+ }
+
+ if e.Type.Kind() != reflect.Ptr {
+ return "json: Unmarshal(non-pointer " + e.Type.String() + ")"
+ }
+ return "json: Unmarshal(nil " + e.Type.String() + ")"
+}
+
+func (d *decodeState) unmarshal(v interface{}) (err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ if _, ok := r.(runtime.Error); ok {
+ panic(r)
+ }
+ err = r.(error)
+ }
+ }()
+
+ rv := reflect.ValueOf(v)
+ if rv.Kind() != reflect.Ptr || rv.IsNil() {
+ return &InvalidUnmarshalError{reflect.TypeOf(v)}
+ }
+
+ d.scan.reset()
+ // We decode rv not rv.Elem because the Unmarshaler interface
+ // test must be applied at the top level of the value.
+ d.value(rv)
+ return d.savedError
+}
+
+// A Number represents a JSON number literal.
+type Number string
+
+// String returns the literal text of the number.
+func (n Number) String() string { return string(n) }
+
+// Float64 returns the number as a float64.
+func (n Number) Float64() (float64, error) {
+ return strconv.ParseFloat(string(n), 64)
+}
+
+// Int64 returns the number as an int64.
+func (n Number) Int64() (int64, error) {
+ return strconv.ParseInt(string(n), 10, 64)
+}
+
+// isValidNumber reports whether s is a valid JSON number literal.
+func isValidNumber(s string) bool {
+ // This function implements the JSON numbers grammar.
+ // See https://tools.ietf.org/html/rfc7159#section-6
+ // and http://json.org/number.gif
+
+ if s == "" {
+ return false
+ }
+
+ // Optional -
+ if s[0] == '-' {
+ s = s[1:]
+ if s == "" {
+ return false
+ }
+ }
+
+ // Digits
+ switch {
+ default:
+ return false
+
+ case s[0] == '0':
+ s = s[1:]
+
+ case '1' <= s[0] && s[0] <= '9':
+ s = s[1:]
+ for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+ s = s[1:]
+ }
+ }
+
+ // . followed by 1 or more digits.
+ if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
+ s = s[2:]
+ for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+ s = s[1:]
+ }
+ }
+
+ // e or E followed by an optional - or + and
+ // 1 or more digits.
+ if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
+ s = s[1:]
+ if s[0] == '+' || s[0] == '-' {
+ s = s[1:]
+ if s == "" {
+ return false
+ }
+ }
+ for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+ s = s[1:]
+ }
+ }
+
+ // Make sure we are at the end.
+ return s == ""
+}
+
+// decodeState represents the state while decoding a JSON value.
+type decodeState struct {
+ data []byte
+ off int // read offset in data
+ scan scanner
+ nextscan scanner // for calls to nextValue
+ savedError error
+ useNumber bool
+ ext Extension
+}
+
+// errPhase is used for errors that should not happen unless
+// there is a bug in the JSON decoder or something is editing
+// the data slice while the decoder executes.
+var errPhase = errors.New("JSON decoder out of sync - data changing underfoot?")
+
+func (d *decodeState) init(data []byte) *decodeState {
+ d.data = data
+ d.off = 0
+ d.savedError = nil
+ return d
+}
+
+// error aborts the decoding by panicking with err.
+func (d *decodeState) error(err error) {
+ panic(err)
+}
+
+// saveError saves the first err it is called with,
+// for reporting at the end of the unmarshal.
+func (d *decodeState) saveError(err error) {
+ if d.savedError == nil {
+ d.savedError = err
+ }
+}
+
+// next cuts off and returns the next full JSON value in d.data[d.off:].
+// The next value is known to be an object or array, not a literal.
+func (d *decodeState) next() []byte {
+ c := d.data[d.off]
+ item, rest, err := nextValue(d.data[d.off:], &d.nextscan)
+ if err != nil {
+ d.error(err)
+ }
+ d.off = len(d.data) - len(rest)
+
+ // Our scanner has seen the opening brace/bracket
+ // and thinks we're still in the middle of the object.
+ // invent a closing brace/bracket to get it out.
+ if c == '{' {
+ d.scan.step(&d.scan, '}')
+ } else if c == '[' {
+ d.scan.step(&d.scan, ']')
+ } else {
+ // Was inside a function name. Get out of it.
+ d.scan.step(&d.scan, '(')
+ d.scan.step(&d.scan, ')')
+ }
+
+ return item
+}
+
+// scanWhile processes bytes in d.data[d.off:] until it
+// receives a scan code not equal to op.
+// It updates d.off and returns the new scan code.
+func (d *decodeState) scanWhile(op int) int {
+ var newOp int
+ for {
+ if d.off >= len(d.data) {
+ newOp = d.scan.eof()
+ d.off = len(d.data) + 1 // mark processed EOF with len+1
+ } else {
+ c := d.data[d.off]
+ d.off++
+ newOp = d.scan.step(&d.scan, c)
+ }
+ if newOp != op {
+ break
+ }
+ }
+ return newOp
+}
+
+// value decodes a JSON value from d.data[d.off:] into the value.
+// it updates d.off to point past the decoded value.
+func (d *decodeState) value(v reflect.Value) {
+ if !v.IsValid() {
+ _, rest, err := nextValue(d.data[d.off:], &d.nextscan)
+ if err != nil {
+ d.error(err)
+ }
+ d.off = len(d.data) - len(rest)
+
+ // d.scan thinks we're still at the beginning of the item.
+ // Feed in an empty string - the shortest, simplest value -
+ // so that it knows we got to the end of the value.
+ if d.scan.redo {
+ // rewind.
+ d.scan.redo = false
+ d.scan.step = stateBeginValue
+ }
+ d.scan.step(&d.scan, '"')
+ d.scan.step(&d.scan, '"')
+
+ n := len(d.scan.parseState)
+ if n > 0 && d.scan.parseState[n-1] == parseObjectKey {
+ // d.scan thinks we just read an object key; finish the object
+ d.scan.step(&d.scan, ':')
+ d.scan.step(&d.scan, '"')
+ d.scan.step(&d.scan, '"')
+ d.scan.step(&d.scan, '}')
+ }
+
+ return
+ }
+
+ switch op := d.scanWhile(scanSkipSpace); op {
+ default:
+ d.error(errPhase)
+
+ case scanBeginArray:
+ d.array(v)
+
+ case scanBeginObject:
+ d.object(v)
+
+ case scanBeginLiteral:
+ d.literal(v)
+
+ case scanBeginName:
+ d.name(v)
+ }
+}
+
+type unquotedValue struct{}
+
+// valueQuoted is like value but decodes a
+// quoted string literal or literal null into an interface value.
+// If it finds anything other than a quoted string literal or null,
+// valueQuoted returns unquotedValue{}.
+func (d *decodeState) valueQuoted() interface{} {
+ switch op := d.scanWhile(scanSkipSpace); op {
+ default:
+ d.error(errPhase)
+
+ case scanBeginArray:
+ d.array(reflect.Value{})
+
+ case scanBeginObject:
+ d.object(reflect.Value{})
+
+ case scanBeginName:
+ switch v := d.nameInterface().(type) {
+ case nil, string:
+ return v
+ }
+
+ case scanBeginLiteral:
+ switch v := d.literalInterface().(type) {
+ case nil, string:
+ return v
+ }
+ }
+ return unquotedValue{}
+}
+
+// indirect walks down v allocating pointers as needed,
+// until it gets to a non-pointer.
+// if it encounters an Unmarshaler, indirect stops and returns that.
+// if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
+func (d *decodeState) indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
+ // If v is a named type and is addressable,
+ // start with its address, so that if the type has pointer methods,
+ // we find them.
+ if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
+ v = v.Addr()
+ }
+ for {
+ // Load value from interface, but only if the result will be
+ // usefully addressable.
+ if v.Kind() == reflect.Interface && !v.IsNil() {
+ e := v.Elem()
+ if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
+ v = e
+ continue
+ }
+ }
+
+ if v.Kind() != reflect.Ptr {
+ break
+ }
+
+ if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
+ break
+ }
+ if v.IsNil() {
+ v.Set(reflect.New(v.Type().Elem()))
+ }
+ if v.Type().NumMethod() > 0 {
+ if u, ok := v.Interface().(Unmarshaler); ok {
+ return u, nil, v
+ }
+ if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
+ return nil, u, v
+ }
+ }
+ v = v.Elem()
+ }
+ return nil, nil, v
+}
+
+// array consumes an array from d.data[d.off-1:], decoding into the value v.
+// the first byte of the array ('[') has been read already.
+func (d *decodeState) array(v reflect.Value) {
+ // Check for unmarshaler.
+ u, ut, pv := d.indirect(v, false)
+ if u != nil {
+ d.off--
+ err := u.UnmarshalJSON(d.next())
+ if err != nil {
+ d.error(err)
+ }
+ return
+ }
+ if ut != nil {
+ d.saveError(&UnmarshalTypeError{"array", v.Type(), int64(d.off)})
+ d.off--
+ d.next()
+ return
+ }
+
+ v = pv
+
+ // Check type of target.
+ switch v.Kind() {
+ case reflect.Interface:
+ if v.NumMethod() == 0 {
+ // Decoding into nil interface? Switch to non-reflect code.
+ v.Set(reflect.ValueOf(d.arrayInterface()))
+ return
+ }
+ // Otherwise it's invalid.
+ fallthrough
+ default:
+ d.saveError(&UnmarshalTypeError{"array", v.Type(), int64(d.off)})
+ d.off--
+ d.next()
+ return
+ case reflect.Array:
+ case reflect.Slice:
+ break
+ }
+
+ i := 0
+ for {
+ // Look ahead for ] - can only happen on first iteration.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndArray {
+ break
+ }
+
+ // Back up so d.value can have the byte we just read.
+ d.off--
+ d.scan.undo(op)
+
+ // Get element of array, growing if necessary.
+ if v.Kind() == reflect.Slice {
+ // Grow slice if necessary
+ if i >= v.Cap() {
+ newcap := v.Cap() + v.Cap()/2
+ if newcap < 4 {
+ newcap = 4
+ }
+ newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
+ reflect.Copy(newv, v)
+ v.Set(newv)
+ }
+ if i >= v.Len() {
+ v.SetLen(i + 1)
+ }
+ }
+
+ if i < v.Len() {
+ // Decode into element.
+ d.value(v.Index(i))
+ } else {
+ // Ran out of fixed array: skip.
+ d.value(reflect.Value{})
+ }
+ i++
+
+ // Next token must be , or ].
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndArray {
+ break
+ }
+ if op != scanArrayValue {
+ d.error(errPhase)
+ }
+ }
+
+ if i < v.Len() {
+ if v.Kind() == reflect.Array {
+ // Array. Zero the rest.
+ z := reflect.Zero(v.Type().Elem())
+ for ; i < v.Len(); i++ {
+ v.Index(i).Set(z)
+ }
+ } else {
+ v.SetLen(i)
+ }
+ }
+ if i == 0 && v.Kind() == reflect.Slice {
+ v.Set(reflect.MakeSlice(v.Type(), 0, 0))
+ }
+}
+
+var nullLiteral = []byte("null")
+var textUnmarshalerType = reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem()
+
+// object consumes an object from d.data[d.off-1:], decoding into the value v.
+// the first byte ('{') of the object has been read already.
+func (d *decodeState) object(v reflect.Value) {
+ // Check for unmarshaler.
+ u, ut, pv := d.indirect(v, false)
+ if d.storeKeyed(pv) {
+ return
+ }
+ if u != nil {
+ d.off--
+ err := u.UnmarshalJSON(d.next())
+ if err != nil {
+ d.error(err)
+ }
+ return
+ }
+ if ut != nil {
+ d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)})
+ d.off--
+ d.next() // skip over { } in input
+ return
+ }
+ v = pv
+
+ // Decoding into nil interface? Switch to non-reflect code.
+ if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
+ v.Set(reflect.ValueOf(d.objectInterface()))
+ return
+ }
+
+ // Check type of target:
+ // struct or
+ // map[string]T or map[encoding.TextUnmarshaler]T
+ switch v.Kind() {
+ case reflect.Map:
+ // Map key must either have string kind or be an encoding.TextUnmarshaler.
+ t := v.Type()
+ if t.Key().Kind() != reflect.String &&
+ !reflect.PtrTo(t.Key()).Implements(textUnmarshalerType) {
+ d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)})
+ d.off--
+ d.next() // skip over { } in input
+ return
+ }
+ if v.IsNil() {
+ v.Set(reflect.MakeMap(t))
+ }
+ case reflect.Struct:
+
+ default:
+ d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)})
+ d.off--
+ d.next() // skip over { } in input
+ return
+ }
+
+ var mapElem reflect.Value
+
+ empty := true
+ for {
+ // Read opening " of string key or closing }.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndObject {
+ if !empty && !d.ext.trailingCommas {
+ d.syntaxError("beginning of object key string")
+ }
+ break
+ }
+ empty = false
+ if op == scanBeginName {
+ if !d.ext.unquotedKeys {
+ d.syntaxError("beginning of object key string")
+ }
+ } else if op != scanBeginLiteral {
+ d.error(errPhase)
+ }
+ unquotedKey := op == scanBeginName
+
+ // Read key.
+ start := d.off - 1
+ op = d.scanWhile(scanContinue)
+ item := d.data[start : d.off-1]
+ var key []byte
+ if unquotedKey {
+ key = item
+ // TODO Fix code below to quote item when necessary.
+ } else {
+ var ok bool
+ key, ok = unquoteBytes(item)
+ if !ok {
+ d.error(errPhase)
+ }
+ }
+
+ // Figure out field corresponding to key.
+ var subv reflect.Value
+ destring := false // whether the value is wrapped in a string to be decoded first
+
+ if v.Kind() == reflect.Map {
+ elemType := v.Type().Elem()
+ if !mapElem.IsValid() {
+ mapElem = reflect.New(elemType).Elem()
+ } else {
+ mapElem.Set(reflect.Zero(elemType))
+ }
+ subv = mapElem
+ } else {
+ var f *field
+ fields := cachedTypeFields(v.Type())
+ for i := range fields {
+ ff := &fields[i]
+ if bytes.Equal(ff.nameBytes, key) {
+ f = ff
+ break
+ }
+ if f == nil && ff.equalFold(ff.nameBytes, key) {
+ f = ff
+ }
+ }
+ if f != nil {
+ subv = v
+ destring = f.quoted
+ for _, i := range f.index {
+ if subv.Kind() == reflect.Ptr {
+ if subv.IsNil() {
+ subv.Set(reflect.New(subv.Type().Elem()))
+ }
+ subv = subv.Elem()
+ }
+ subv = subv.Field(i)
+ }
+ }
+ }
+
+ // Read : before value.
+ if op == scanSkipSpace {
+ op = d.scanWhile(scanSkipSpace)
+ }
+ if op != scanObjectKey {
+ d.error(errPhase)
+ }
+
+ // Read value.
+ if destring {
+ switch qv := d.valueQuoted().(type) {
+ case nil:
+ d.literalStore(nullLiteral, subv, false)
+ case string:
+ d.literalStore([]byte(qv), subv, true)
+ default:
+ d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
+ }
+ } else {
+ d.value(subv)
+ }
+
+ // Write value back to map;
+ // if using struct, subv points into struct already.
+ if v.Kind() == reflect.Map {
+ kt := v.Type().Key()
+ var kv reflect.Value
+ switch {
+ case kt.Kind() == reflect.String:
+ kv = reflect.ValueOf(key).Convert(v.Type().Key())
+ case reflect.PtrTo(kt).Implements(textUnmarshalerType):
+ kv = reflect.New(v.Type().Key())
+ d.literalStore(item, kv, true)
+ kv = kv.Elem()
+ default:
+ panic("json: Unexpected key type") // should never occur
+ }
+ v.SetMapIndex(kv, subv)
+ }
+
+ // Next token must be , or }.
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndObject {
+ break
+ }
+ if op != scanObjectValue {
+ d.error(errPhase)
+ }
+ }
+}
+
+// isNull returns whether there's a null literal at the provided offset.
+func (d *decodeState) isNull(off int) bool {
+ if off+4 >= len(d.data) || d.data[off] != 'n' || d.data[off+1] != 'u' || d.data[off+2] != 'l' || d.data[off+3] != 'l' {
+ return false
+ }
+ d.nextscan.reset()
+ for i, c := range d.data[off:] {
+ if i > 4 {
+ return false
+ }
+ switch d.nextscan.step(&d.nextscan, c) {
+ case scanContinue, scanBeginName:
+ continue
+ }
+ break
+ }
+ return true
+}
+
+// name consumes a const or function from d.data[d.off-1:], decoding into the value v.
+// the first byte of the function name has been read already.
+func (d *decodeState) name(v reflect.Value) {
+ if d.isNull(d.off - 1) {
+ d.literal(v)
+ return
+ }
+
+ // Check for unmarshaler.
+ u, ut, pv := d.indirect(v, false)
+ if d.storeKeyed(pv) {
+ return
+ }
+ if u != nil {
+ d.off--
+ err := u.UnmarshalJSON(d.next())
+ if err != nil {
+ d.error(err)
+ }
+ return
+ }
+ if ut != nil {
+ d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)})
+ d.off--
+ d.next() // skip over function in input
+ return
+ }
+ v = pv
+
+ // Decoding into nil interface? Switch to non-reflect code.
+ if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
+ out := d.nameInterface()
+ if out == nil {
+ v.Set(reflect.Zero(v.Type()))
+ } else {
+ v.Set(reflect.ValueOf(out))
+ }
+ return
+ }
+
+ nameStart := d.off - 1
+
+ op := d.scanWhile(scanContinue)
+
+ name := d.data[nameStart : d.off-1]
+ if op != scanParam {
+ // Back up so the byte just read is consumed next.
+ d.off--
+ d.scan.undo(op)
+ if l, ok := d.convertLiteral(name); ok {
+ d.storeValue(v, l)
+ return
+ }
+ d.error(&SyntaxError{fmt.Sprintf("json: unknown constant %q", name), int64(d.off)})
+ }
+
+ funcName := string(name)
+ funcData := d.ext.funcs[funcName]
+ if funcData.key == "" {
+ d.error(fmt.Errorf("json: unknown function %q", funcName))
+ }
+
+ // Check type of target:
+ // struct or
+ // map[string]T or map[encoding.TextUnmarshaler]T
+ switch v.Kind() {
+ case reflect.Map:
+ // Map key must either have string kind or be an encoding.TextUnmarshaler.
+ t := v.Type()
+ if t.Key().Kind() != reflect.String &&
+ !reflect.PtrTo(t.Key()).Implements(textUnmarshalerType) {
+ d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)})
+ d.off--
+ d.next() // skip over { } in input
+ return
+ }
+ if v.IsNil() {
+ v.Set(reflect.MakeMap(t))
+ }
+ case reflect.Struct:
+
+ default:
+ d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)})
+ d.off--
+ d.next() // skip over { } in input
+ return
+ }
+
+ // TODO Fix case of func field as map.
+ //topv := v
+
+ // Figure out field corresponding to function.
+ key := []byte(funcData.key)
+ if v.Kind() == reflect.Map {
+ elemType := v.Type().Elem()
+ v = reflect.New(elemType).Elem()
+ } else {
+ var f *field
+ fields := cachedTypeFields(v.Type())
+ for i := range fields {
+ ff := &fields[i]
+ if bytes.Equal(ff.nameBytes, key) {
+ f = ff
+ break
+ }
+ if f == nil && ff.equalFold(ff.nameBytes, key) {
+ f = ff
+ }
+ }
+ if f != nil {
+ for _, i := range f.index {
+ if v.Kind() == reflect.Ptr {
+ if v.IsNil() {
+ v.Set(reflect.New(v.Type().Elem()))
+ }
+ v = v.Elem()
+ }
+ v = v.Field(i)
+ }
+ if v.Kind() == reflect.Ptr {
+ if v.IsNil() {
+ v.Set(reflect.New(v.Type().Elem()))
+ }
+ v = v.Elem()
+ }
+ }
+ }
+
+ // Check for unmarshaler on func field itself.
+ u, _, _ = d.indirect(v, false)
+ if u != nil {
+ d.off = nameStart
+ err := u.UnmarshalJSON(d.next())
+ if err != nil {
+ d.error(err)
+ }
+ return
+ }
+
+ var mapElem reflect.Value
+
+ // Parse function arguments.
+ for i := 0; ; i++ {
+ // closing ) - can only happen on first iteration.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndParams {
+ break
+ }
+
+ // Back up so d.value can have the byte we just read.
+ d.off--
+ d.scan.undo(op)
+
+ if i >= len(funcData.args) {
+ d.error(fmt.Errorf("json: too many arguments for function %s", funcName))
+ }
+ key := []byte(funcData.args[i])
+
+ // Figure out field corresponding to key.
+ var subv reflect.Value
+ destring := false // whether the value is wrapped in a string to be decoded first
+
+ if v.Kind() == reflect.Map {
+ elemType := v.Type().Elem()
+ if !mapElem.IsValid() {
+ mapElem = reflect.New(elemType).Elem()
+ } else {
+ mapElem.Set(reflect.Zero(elemType))
+ }
+ subv = mapElem
+ } else {
+ var f *field
+ fields := cachedTypeFields(v.Type())
+ for i := range fields {
+ ff := &fields[i]
+ if bytes.Equal(ff.nameBytes, key) {
+ f = ff
+ break
+ }
+ if f == nil && ff.equalFold(ff.nameBytes, key) {
+ f = ff
+ }
+ }
+ if f != nil {
+ subv = v
+ destring = f.quoted
+ for _, i := range f.index {
+ if subv.Kind() == reflect.Ptr {
+ if subv.IsNil() {
+ subv.Set(reflect.New(subv.Type().Elem()))
+ }
+ subv = subv.Elem()
+ }
+ subv = subv.Field(i)
+ }
+ }
+ }
+
+ // Read value.
+ if destring {
+ switch qv := d.valueQuoted().(type) {
+ case nil:
+ d.literalStore(nullLiteral, subv, false)
+ case string:
+ d.literalStore([]byte(qv), subv, true)
+ default:
+ d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
+ }
+ } else {
+ d.value(subv)
+ }
+
+ // Write value back to map;
+ // if using struct, subv points into struct already.
+ if v.Kind() == reflect.Map {
+ kt := v.Type().Key()
+ var kv reflect.Value
+ switch {
+ case kt.Kind() == reflect.String:
+ kv = reflect.ValueOf(key).Convert(v.Type().Key())
+ case reflect.PtrTo(kt).Implements(textUnmarshalerType):
+ kv = reflect.New(v.Type().Key())
+ d.literalStore(key, kv, true)
+ kv = kv.Elem()
+ default:
+ panic("json: Unexpected key type") // should never occur
+ }
+ v.SetMapIndex(kv, subv)
+ }
+
+ // Next token must be , or ).
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndParams {
+ break
+ }
+ if op != scanParam {
+ d.error(errPhase)
+ }
+ }
+}
+
+// keyed attempts to decode an object or function using a keyed doc extension,
+// and returns the value and true on success, or nil and false otherwise.
+func (d *decodeState) keyed() (interface{}, bool) {
+ if len(d.ext.keyed) == 0 {
+ return nil, false
+ }
+
+ unquote := false
+
+ // Look-ahead first key to check for a keyed document extension.
+ d.nextscan.reset()
+ var start, end int
+ for i, c := range d.data[d.off-1:] {
+ switch op := d.nextscan.step(&d.nextscan, c); op {
+ case scanSkipSpace, scanContinue, scanBeginObject:
+ continue
+ case scanBeginLiteral, scanBeginName:
+ unquote = op == scanBeginLiteral
+ start = i
+ continue
+ }
+ end = i
+ break
+ }
+
+ name := bytes.Trim(d.data[d.off-1+start:d.off-1+end], " \n\t")
+
+ var key []byte
+ var ok bool
+ if unquote {
+ key, ok = unquoteBytes(name)
+ if !ok {
+ d.error(errPhase)
+ }
+ } else {
+ funcData, ok := d.ext.funcs[string(name)]
+ if !ok {
+ return nil, false
+ }
+ key = []byte(funcData.key)
+ }
+
+ decode, ok := d.ext.keyed[string(key)]
+ if !ok {
+ return nil, false
+ }
+
+ d.off--
+ out, err := decode(d.next())
+ if err != nil {
+ d.error(err)
+ }
+ return out, true
+}
+
+func (d *decodeState) storeKeyed(v reflect.Value) bool {
+ keyed, ok := d.keyed()
+ if !ok {
+ return false
+ }
+ d.storeValue(v, keyed)
+ return true
+}
+
+var (
+ trueBytes = []byte("true")
+ falseBytes = []byte("false")
+ nullBytes = []byte("null")
+)
+
+func (d *decodeState) storeValue(v reflect.Value, from interface{}) {
+ switch from {
+ case nil:
+ d.literalStore(nullBytes, v, false)
+ return
+ case true:
+ d.literalStore(trueBytes, v, false)
+ return
+ case false:
+ d.literalStore(falseBytes, v, false)
+ return
+ }
+ fromv := reflect.ValueOf(from)
+ for fromv.Kind() == reflect.Ptr && !fromv.IsNil() {
+ fromv = fromv.Elem()
+ }
+ fromt := fromv.Type()
+ for v.Kind() == reflect.Ptr && !v.IsNil() {
+ v = v.Elem()
+ }
+ vt := v.Type()
+ if fromt.AssignableTo(vt) {
+ v.Set(fromv)
+ } else if fromt.ConvertibleTo(vt) {
+ v.Set(fromv.Convert(vt))
+ } else {
+ d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)})
+ }
+}
+
+func (d *decodeState) convertLiteral(name []byte) (interface{}, bool) {
+ if len(name) == 0 {
+ return nil, false
+ }
+ switch name[0] {
+ case 't':
+ if bytes.Equal(name, trueBytes) {
+ return true, true
+ }
+ case 'f':
+ if bytes.Equal(name, falseBytes) {
+ return false, true
+ }
+ case 'n':
+ if bytes.Equal(name, nullBytes) {
+ return nil, true
+ }
+ }
+ if l, ok := d.ext.consts[string(name)]; ok {
+ return l, true
+ }
+ return nil, false
+}
+
+// literal consumes a literal from d.data[d.off-1:], decoding into the value v.
+// The first byte of the literal has been read already
+// (that's how the caller knows it's a literal).
+func (d *decodeState) literal(v reflect.Value) {
+ // All bytes inside literal return scanContinue op code.
+ start := d.off - 1
+ op := d.scanWhile(scanContinue)
+
+ // Scan read one byte too far; back up.
+ d.off--
+ d.scan.undo(op)
+
+ d.literalStore(d.data[start:d.off], v, false)
+}
+
+// convertNumber converts the number literal s to a float64 or a Number
+// depending on the setting of d.useNumber.
+func (d *decodeState) convertNumber(s string) (interface{}, error) {
+ if d.useNumber {
+ return Number(s), nil
+ }
+ f, err := strconv.ParseFloat(s, 64)
+ if err != nil {
+ return nil, &UnmarshalTypeError{"number " + s, reflect.TypeOf(0.0), int64(d.off)}
+ }
+ return f, nil
+}
+
+var numberType = reflect.TypeOf(Number(""))
+
+// literalStore decodes a literal stored in item into v.
+//
+// fromQuoted indicates whether this literal came from unwrapping a
+// string from the ",string" struct tag option. this is used only to
+// produce more helpful error messages.
+func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) {
+ // Check for unmarshaler.
+ if len(item) == 0 {
+ //Empty string given
+ d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
+ return
+ }
+ wantptr := item[0] == 'n' // null
+ u, ut, pv := d.indirect(v, wantptr)
+ if u != nil {
+ err := u.UnmarshalJSON(item)
+ if err != nil {
+ d.error(err)
+ }
+ return
+ }
+ if ut != nil {
+ if item[0] != '"' {
+ if fromQuoted {
+ d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
+ } else {
+ d.saveError(&UnmarshalTypeError{"string", v.Type(), int64(d.off)})
+ }
+ return
+ }
+ s, ok := unquoteBytes(item)
+ if !ok {
+ if fromQuoted {
+ d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
+ } else {
+ d.error(errPhase)
+ }
+ }
+ err := ut.UnmarshalText(s)
+ if err != nil {
+ d.error(err)
+ }
+ return
+ }
+
+ v = pv
+
+ switch c := item[0]; c {
+ case 'n': // null
+ switch v.Kind() {
+ case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
+ v.Set(reflect.Zero(v.Type()))
+ // otherwise, ignore null for primitives/string
+ }
+ case 't', 'f': // true, false
+ value := c == 't'
+ switch v.Kind() {
+ default:
+ if fromQuoted {
+ d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
+ } else {
+ d.saveError(&UnmarshalTypeError{"bool", v.Type(), int64(d.off)})
+ }
+ case reflect.Bool:
+ v.SetBool(value)
+ case reflect.Interface:
+ if v.NumMethod() == 0 {
+ v.Set(reflect.ValueOf(value))
+ } else {
+ d.saveError(&UnmarshalTypeError{"bool", v.Type(), int64(d.off)})
+ }
+ }
+
+ case '"': // string
+ s, ok := unquoteBytes(item)
+ if !ok {
+ if fromQuoted {
+ d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
+ } else {
+ d.error(errPhase)
+ }
+ }
+ switch v.Kind() {
+ default:
+ d.saveError(&UnmarshalTypeError{"string", v.Type(), int64(d.off)})
+ case reflect.Slice:
+ if v.Type().Elem().Kind() != reflect.Uint8 {
+ d.saveError(&UnmarshalTypeError{"string", v.Type(), int64(d.off)})
+ break
+ }
+ b := make([]byte, base64.StdEncoding.DecodedLen(len(s)))
+ n, err := base64.StdEncoding.Decode(b, s)
+ if err != nil {
+ d.saveError(err)
+ break
+ }
+ v.SetBytes(b[:n])
+ case reflect.String:
+ v.SetString(string(s))
+ case reflect.Interface:
+ if v.NumMethod() == 0 {
+ v.Set(reflect.ValueOf(string(s)))
+ } else {
+ d.saveError(&UnmarshalTypeError{"string", v.Type(), int64(d.off)})
+ }
+ }
+
+ default: // number
+ if c != '-' && (c < '0' || c > '9') {
+ if fromQuoted {
+ d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
+ } else {
+ d.error(errPhase)
+ }
+ }
+ s := string(item)
+ switch v.Kind() {
+ default:
+ if v.Kind() == reflect.String && v.Type() == numberType {
+ v.SetString(s)
+ if !isValidNumber(s) {
+ d.error(fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item))
+ }
+ break
+ }
+ if fromQuoted {
+ d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
+ } else {
+ d.error(&UnmarshalTypeError{"number", v.Type(), int64(d.off)})
+ }
+ case reflect.Interface:
+ n, err := d.convertNumber(s)
+ if err != nil {
+ d.saveError(err)
+ break
+ }
+ if v.NumMethod() != 0 {
+ d.saveError(&UnmarshalTypeError{"number", v.Type(), int64(d.off)})
+ break
+ }
+ v.Set(reflect.ValueOf(n))
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ n, err := strconv.ParseInt(s, 10, 64)
+ if err != nil || v.OverflowInt(n) {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type(), int64(d.off)})
+ break
+ }
+ v.SetInt(n)
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ n, err := strconv.ParseUint(s, 10, 64)
+ if err != nil || v.OverflowUint(n) {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type(), int64(d.off)})
+ break
+ }
+ v.SetUint(n)
+
+ case reflect.Float32, reflect.Float64:
+ n, err := strconv.ParseFloat(s, v.Type().Bits())
+ if err != nil || v.OverflowFloat(n) {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type(), int64(d.off)})
+ break
+ }
+ v.SetFloat(n)
+ }
+ }
+}
+
+// The xxxInterface routines build up a value to be stored
+// in an empty interface. They are not strictly necessary,
+// but they avoid the weight of reflection in this common case.
+
+// valueInterface is like value but returns interface{}
+func (d *decodeState) valueInterface() interface{} {
+ switch d.scanWhile(scanSkipSpace) {
+ default:
+ d.error(errPhase)
+ panic("unreachable")
+ case scanBeginArray:
+ return d.arrayInterface()
+ case scanBeginObject:
+ return d.objectInterface()
+ case scanBeginLiteral:
+ return d.literalInterface()
+ case scanBeginName:
+ return d.nameInterface()
+ }
+}
+
+func (d *decodeState) syntaxError(expected string) {
+ msg := fmt.Sprintf("invalid character '%c' looking for %s", d.data[d.off-1], expected)
+ d.error(&SyntaxError{msg, int64(d.off)})
+}
+
+// arrayInterface is like array but returns []interface{}.
+func (d *decodeState) arrayInterface() []interface{} {
+ var v = make([]interface{}, 0)
+ for {
+ // Look ahead for ] - can only happen on first iteration.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndArray {
+ if len(v) > 0 && !d.ext.trailingCommas {
+ d.syntaxError("beginning of value")
+ }
+ break
+ }
+
+ // Back up so d.value can have the byte we just read.
+ d.off--
+ d.scan.undo(op)
+
+ v = append(v, d.valueInterface())
+
+ // Next token must be , or ].
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndArray {
+ break
+ }
+ if op != scanArrayValue {
+ d.error(errPhase)
+ }
+ }
+ return v
+}
+
+// objectInterface is like object but returns map[string]interface{}.
+func (d *decodeState) objectInterface() interface{} {
+ v, ok := d.keyed()
+ if ok {
+ return v
+ }
+
+ m := make(map[string]interface{})
+ for {
+ // Read opening " of string key or closing }.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndObject {
+ if len(m) > 0 && !d.ext.trailingCommas {
+ d.syntaxError("beginning of object key string")
+ }
+ break
+ }
+ if op == scanBeginName {
+ if !d.ext.unquotedKeys {
+ d.syntaxError("beginning of object key string")
+ }
+ } else if op != scanBeginLiteral {
+ d.error(errPhase)
+ }
+ unquotedKey := op == scanBeginName
+
+ // Read string key.
+ start := d.off - 1
+ op = d.scanWhile(scanContinue)
+ item := d.data[start : d.off-1]
+ var key string
+ if unquotedKey {
+ key = string(item)
+ } else {
+ var ok bool
+ key, ok = unquote(item)
+ if !ok {
+ d.error(errPhase)
+ }
+ }
+
+ // Read : before value.
+ if op == scanSkipSpace {
+ op = d.scanWhile(scanSkipSpace)
+ }
+ if op != scanObjectKey {
+ d.error(errPhase)
+ }
+
+ // Read value.
+ m[key] = d.valueInterface()
+
+ // Next token must be , or }.
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndObject {
+ break
+ }
+ if op != scanObjectValue {
+ d.error(errPhase)
+ }
+ }
+ return m
+}
+
+// literalInterface is like literal but returns an interface value.
+func (d *decodeState) literalInterface() interface{} {
+ // All bytes inside literal return scanContinue op code.
+ start := d.off - 1
+ op := d.scanWhile(scanContinue)
+
+ // Scan read one byte too far; back up.
+ d.off--
+ d.scan.undo(op)
+ item := d.data[start:d.off]
+
+ switch c := item[0]; c {
+ case 'n': // null
+ return nil
+
+ case 't', 'f': // true, false
+ return c == 't'
+
+ case '"': // string
+ s, ok := unquote(item)
+ if !ok {
+ d.error(errPhase)
+ }
+ return s
+
+ default: // number
+ if c != '-' && (c < '0' || c > '9') {
+ d.error(errPhase)
+ }
+ n, err := d.convertNumber(string(item))
+ if err != nil {
+ d.saveError(err)
+ }
+ return n
+ }
+}
+
+// nameInterface is like function but returns map[string]interface{}.
+func (d *decodeState) nameInterface() interface{} {
+ v, ok := d.keyed()
+ if ok {
+ return v
+ }
+
+ nameStart := d.off - 1
+
+ op := d.scanWhile(scanContinue)
+
+ name := d.data[nameStart : d.off-1]
+ if op != scanParam {
+ // Back up so the byte just read is consumed next.
+ d.off--
+ d.scan.undo(op)
+ if l, ok := d.convertLiteral(name); ok {
+ return l
+ }
+ d.error(&SyntaxError{fmt.Sprintf("json: unknown constant %q", name), int64(d.off)})
+ }
+
+ funcName := string(name)
+ funcData := d.ext.funcs[funcName]
+ if funcData.key == "" {
+ d.error(fmt.Errorf("json: unknown function %q", funcName))
+ }
+
+ m := make(map[string]interface{})
+ for i := 0; ; i++ {
+ // Look ahead for ) - can only happen on first iteration.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndParams {
+ break
+ }
+
+ // Back up so d.value can have the byte we just read.
+ d.off--
+ d.scan.undo(op)
+
+ if i >= len(funcData.args) {
+ d.error(fmt.Errorf("json: too many arguments for function %s", funcName))
+ }
+ m[funcData.args[i]] = d.valueInterface()
+
+ // Next token must be , or ).
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndParams {
+ break
+ }
+ if op != scanParam {
+ d.error(errPhase)
+ }
+ }
+ return map[string]interface{}{funcData.key: m}
+}
+
+// getu4 decodes \uXXXX from the beginning of s, returning the hex value,
+// or it returns -1.
+func getu4(s []byte) rune {
+ if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
+ return -1
+ }
+ r, err := strconv.ParseUint(string(s[2:6]), 16, 64)
+ if err != nil {
+ return -1
+ }
+ return rune(r)
+}
+
+// unquote converts a quoted JSON string literal s into an actual string t.
+// The rules are different than for Go, so cannot use strconv.Unquote.
+func unquote(s []byte) (t string, ok bool) {
+ s, ok = unquoteBytes(s)
+ t = string(s)
+ return
+}
+
+func unquoteBytes(s []byte) (t []byte, ok bool) {
+ if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
+ return
+ }
+ s = s[1 : len(s)-1]
+
+ // Check for unusual characters. If there are none,
+ // then no unquoting is needed, so return a slice of the
+ // original bytes.
+ r := 0
+ for r < len(s) {
+ c := s[r]
+ if c == '\\' || c == '"' || c < ' ' {
+ break
+ }
+ if c < utf8.RuneSelf {
+ r++
+ continue
+ }
+ rr, size := utf8.DecodeRune(s[r:])
+ if rr == utf8.RuneError && size == 1 {
+ break
+ }
+ r += size
+ }
+ if r == len(s) {
+ return s, true
+ }
+
+ b := make([]byte, len(s)+2*utf8.UTFMax)
+ w := copy(b, s[0:r])
+ for r < len(s) {
+ // Out of room? Can only happen if s is full of
+ // malformed UTF-8 and we're replacing each
+ // byte with RuneError.
+ if w >= len(b)-2*utf8.UTFMax {
+ nb := make([]byte, (len(b)+utf8.UTFMax)*2)
+ copy(nb, b[0:w])
+ b = nb
+ }
+ switch c := s[r]; {
+ case c == '\\':
+ r++
+ if r >= len(s) {
+ return
+ }
+ switch s[r] {
+ default:
+ return
+ case '"', '\\', '/', '\'':
+ b[w] = s[r]
+ r++
+ w++
+ case 'b':
+ b[w] = '\b'
+ r++
+ w++
+ case 'f':
+ b[w] = '\f'
+ r++
+ w++
+ case 'n':
+ b[w] = '\n'
+ r++
+ w++
+ case 'r':
+ b[w] = '\r'
+ r++
+ w++
+ case 't':
+ b[w] = '\t'
+ r++
+ w++
+ case 'u':
+ r--
+ rr := getu4(s[r:])
+ if rr < 0 {
+ return
+ }
+ r += 6
+ if utf16.IsSurrogate(rr) {
+ rr1 := getu4(s[r:])
+ if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
+ // A valid pair; consume.
+ r += 6
+ w += utf8.EncodeRune(b[w:], dec)
+ break
+ }
+ // Invalid surrogate; fall back to replacement rune.
+ rr = unicode.ReplacementChar
+ }
+ w += utf8.EncodeRune(b[w:], rr)
+ }
+
+ // Quote, control characters are invalid.
+ case c == '"', c < ' ':
+ return
+
+ // ASCII
+ case c < utf8.RuneSelf:
+ b[w] = c
+ r++
+ w++
+
+ // Coerce to well-formed UTF-8.
+ default:
+ rr, size := utf8.DecodeRune(s[r:])
+ r += size
+ w += utf8.EncodeRune(b[w:], rr)
+ }
+ }
+ return b[0:w], true
+}
diff --git a/vendor/github.com/globalsign/mgo/internal/json/encode.go b/vendor/github.com/globalsign/mgo/internal/json/encode.go
new file mode 100644
index 0000000000..e4b8f86487
--- /dev/null
+++ b/vendor/github.com/globalsign/mgo/internal/json/encode.go
@@ -0,0 +1,1260 @@
+// Copyright 2010 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 json implements encoding and decoding of JSON as defined in
+// RFC 4627. The mapping between JSON and Go values is described
+// in the documentation for the Marshal and Unmarshal functions.
+//
+// See "JSON and Go" for an introduction to this package:
+// https://golang.org/doc/articles/json_and_go.html
+package json
+
+import (
+ "bytes"
+ "encoding"
+ "encoding/base64"
+ "fmt"
+ "math"
+ "reflect"
+ "runtime"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+ "unicode"
+ "unicode/utf8"
+)
+
+// Marshal returns the JSON encoding of v.
+//
+// Marshal traverses the value v recursively.
+// If an encountered value implements the Marshaler interface
+// and is not a nil pointer, Marshal calls its MarshalJSON method
+// to produce JSON. If no MarshalJSON method is present but the
+// value implements encoding.TextMarshaler instead, Marshal calls
+// its MarshalText method.
+// The nil pointer exception is not strictly necessary
+// but mimics a similar, necessary exception in the behavior of
+// UnmarshalJSON.
+//
+// Otherwise, Marshal uses the following type-dependent default encodings:
+//
+// Boolean values encode as JSON booleans.
+//
+// Floating point, integer, and Number values encode as JSON numbers.
+//
+// String values encode as JSON strings coerced to valid UTF-8,
+// replacing invalid bytes with the Unicode replacement rune.
+// The angle brackets "<" and ">" are escaped to "\u003c" and "\u003e"
+// to keep some browsers from misinterpreting JSON output as HTML.
+// Ampersand "&" is also escaped to "\u0026" for the same reason.
+// This escaping can be disabled using an Encoder with DisableHTMLEscaping.
+//
+// Array and slice values encode as JSON arrays, except that
+// []byte encodes as a base64-encoded string, and a nil slice
+// encodes as the null JSON value.
+//
+// Struct values encode as JSON objects. Each exported struct field
+// becomes a member of the object unless
+// - the field's tag is "-", or
+// - the field is empty and its tag specifies the "omitempty" option.
+// The empty values are false, 0, any
+// nil pointer or interface value, and any array, slice, map, or string of
+// length zero. The object's default key string is the struct field name
+// but can be specified in the struct field's tag value. The "json" key in
+// the struct field's tag value is the key name, followed by an optional comma
+// and options. Examples:
+//
+// // Field is ignored by this package.
+// Field int `json:"-"`
+//
+// // Field appears in JSON as key "myName".
+// Field int `json:"myName"`
+//
+// // Field appears in JSON as key "myName" and
+// // the field is omitted from the object if its value is empty,
+// // as defined above.
+// Field int `json:"myName,omitempty"`
+//
+// // Field appears in JSON as key "Field" (the default), but
+// // the field is skipped if empty.
+// // Note the leading comma.
+// Field int `json:",omitempty"`
+//
+// The "string" option signals that a field is stored as JSON inside a
+// JSON-encoded string. It applies only to fields of string, floating point,
+// integer, or boolean types. This extra level of encoding is sometimes used
+// when communicating with JavaScript programs:
+//
+// Int64String int64 `json:",string"`
+//
+// The key name will be used if it's a non-empty string consisting of
+// only Unicode letters, digits, dollar signs, percent signs, hyphens,
+// underscores and slashes.
+//
+// Anonymous struct fields are usually marshaled as if their inner exported fields
+// were fields in the outer struct, subject to the usual Go visibility rules amended
+// as described in the next paragraph.
+// An anonymous struct field with a name given in its JSON tag is treated as
+// having that name, rather than being anonymous.
+// An anonymous struct field of interface type is treated the same as having
+// that type as its name, rather than being anonymous.
+//
+// The Go visibility rules for struct fields are amended for JSON when
+// deciding which field to marshal or unmarshal. If there are
+// multiple fields at the same level, and that level is the least
+// nested (and would therefore be the nesting level selected by the
+// usual Go rules), the following extra rules apply:
+//
+// 1) Of those fields, if any are JSON-tagged, only tagged fields are considered,
+// even if there are multiple untagged fields that would otherwise conflict.
+// 2) If there is exactly one field (tagged or not according to the first rule), that is selected.
+// 3) Otherwise there are multiple fields, and all are ignored; no error occurs.
+//
+// Handling of anonymous struct fields is new in Go 1.1.
+// Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of
+// an anonymous struct field in both current and earlier versions, give the field
+// a JSON tag of "-".
+//
+// Map values encode as JSON objects. The map's key type must either be a string
+// or implement encoding.TextMarshaler. The map keys are used as JSON object
+// keys, subject to the UTF-8 coercion described for string values above.
+//
+// Pointer values encode as the value pointed to.
+// A nil pointer encodes as the null JSON value.
+//
+// Interface values encode as the value contained in the interface.
+// A nil interface value encodes as the null JSON value.
+//
+// Channel, complex, and function values cannot be encoded in JSON.
+// Attempting to encode such a value causes Marshal to return
+// an UnsupportedTypeError.
+//
+// JSON cannot represent cyclic data structures and Marshal does not
+// handle them. Passing cyclic structures to Marshal will result in
+// an infinite recursion.
+//
+func Marshal(v interface{}) ([]byte, error) {
+ e := &encodeState{}
+ err := e.marshal(v, encOpts{escapeHTML: true})
+ if err != nil {
+ return nil, err
+ }
+ return e.Bytes(), nil
+}
+
+// MarshalIndent is like Marshal but applies Indent to format the output.
+func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
+ b, err := Marshal(v)
+ if err != nil {
+ return nil, err
+ }
+ var buf bytes.Buffer
+ err = Indent(&buf, b, prefix, indent)
+ if err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil
+}
+
+// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029
+// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029
+// so that the JSON will be safe to embed inside HTML