Update kubernetes/client-go to v7.0.0 (#1808)

This fix updates k8s' client-go to v7.0.0, which matches k8s 1.10.
Signed-off-by: Yong Tang <yong.tang.github@outlook.com>

Gopkg.lock

@@ -11,18 +11,6 @@
   revision = "27617015d45e6cd550b9a7ac7715c37cc2f7d020"
   version = "v0.6.1"
 
-[[projects]]
-  name = "github.com/PuerkitoBio/purell"
-  packages = ["."]
-  revision = "0bcb03f4b4d0a9428594752bd2a3b9aa0a9d4bd4"
-  version = "v1.1.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/PuerkitoBio/urlesc"
-  packages = ["."]
-  revision = "de5bf2ad457846296e2031421a34e2568e304e35"
-
 [[projects]]
   name = "github.com/Shopify/sarama"
   packages = ["."]
@@ -117,15 +105,6 @@
   revision = "44cc805cf13205b55f69e14bcb69867d1ae92f98"
   version = "v1.1.0"
 
-[[projects]]
-  name = "github.com/emicklei/go-restful"
-  packages = [
-    ".",
-    "log"
-  ]
-  revision = "2810ccc68e0ca445fa81ebfa03fbf70aca5c41ae"
-  version = "v2.7.0"
-
 [[projects]]
   branch = "master"
   name = "github.com/farsightsec/golang-framestream"
@@ -150,30 +129,6 @@
   revision = "390ab7935ee28ec6b286364bba9b4dd6410cb3d5"
   version = "v0.3.0"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/go-openapi/jsonpointer"
-  packages = ["."]
-  revision = "3a0015ad55fa9873f41605d3e8f28cd279c32ab2"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/go-openapi/jsonreference"
-  packages = ["."]
-  revision = "3fb327e6747da3043567ee86abd02bb6376b6be2"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/go-openapi/spec"
-  packages = ["."]
-  revision = "bcff419492eeeb01f76e77d2ebc714dc97b607f5"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/go-openapi/swag"
-  packages = ["."]
-  revision = "811b1089cde9dad18d4d0c2d09fbdbf28dbd27a5"
-
 [[projects]]
   name = "github.com/gogo/protobuf"
   packages = [
@@ -207,12 +162,6 @@
   packages = ["."]
   revision = "553a641470496b2327abcac10b36396bd98e45c9"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/google/btree"
-  packages = ["."]
-  revision = "e89373fe6b4a7413d7acd6da1725b83ef713e6e4"
-
 [[projects]]
   branch = "master"
   name = "github.com/google/gofuzz"
@@ -229,15 +178,6 @@
   revision = "ee43cbb60db7bd22502942cccbc39059117352ab"
   version = "v0.1.0"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/gregjones/httpcache"
-  packages = [
-    ".",
-    "diskcache"
-  ]
-  revision = "9cad4c3443a7200dd6400aef47183728de563a38"
-
 [[projects]]
   branch = "master"
   name = "github.com/grpc-ecosystem/grpc-opentracing"
@@ -276,28 +216,12 @@
   revision = "ca39e5af3ece67bbcda3d0f4f56a8e24d9f2dad4"
   version = "1.1.3"
 
-[[projects]]
-  name = "github.com/juju/ratelimit"
-  packages = ["."]
-  revision = "59fac5042749a5afb9af70e813da1dd5474f0167"
-  version = "1.0.1"
-
 [[projects]]
   branch = "master"
   name = "github.com/kr/logfmt"
   packages = ["."]
   revision = "b84e30acd515aadc4b783ad4ff83aff3299bdfe0"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/mailru/easyjson"
-  packages = [
-    "buffer",
-    "jlexer",
-    "jwriter"
-  ]
-  revision = "8b799c424f57fa123fc63a99d6383bc6e4c02578"
-
 [[projects]]
   name = "github.com/matttproud/golang_protobuf_extensions"
   packages = ["pbutil"]
@@ -345,18 +269,6 @@
   revision = "26cf9707480e6b90e5eff22cf0bbf05319154232"
   version = "v0.3.4"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/petar/GoLLRB"
-  packages = ["llrb"]
-  revision = "53be0d36a84c2a886ca057d34b6aa4468df9ccb4"
-
-[[projects]]
-  name = "github.com/peterbourgon/diskv"
-  packages = ["."]
-  revision = "5f041e8faa004a95c88a202771f4cc3e991971e6"
-  version = "v2.0.1"
-
 [[projects]]
   name = "github.com/pierrec/lz4"
   packages = ["."]
@@ -447,12 +359,17 @@
     "unicode/bidi",
     "unicode/cldr",
     "unicode/norm",
-    "unicode/rangetable",
-    "width"
+    "unicode/rangetable"
   ]
   revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
   version = "v0.3.0"
 
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/time"
+  packages = ["rate"]
+  revision = "fbb02b2291d28baffd63558aa44b4b56f178d650"
+
 [[projects]]
   branch = "master"
   name = "google.golang.org/genproto"
@@ -534,7 +451,7 @@
     "storage/v1alpha1",
     "storage/v1beta1"
   ]
-  revision = "11147472b7c934c474a2c484af3c0c5210b7a3af"
+  revision = "73d903622b7391f3312dcbac6483fed484e185f8"
 
 [[projects]]
   name = "k8s.io/apimachinery"
@@ -545,7 +462,7 @@
     "pkg/apis/meta/internalversion",
     "pkg/apis/meta/v1",
     "pkg/apis/meta/v1/unstructured",
-    "pkg/apis/meta/v1alpha1",
+    "pkg/apis/meta/v1beta1",
     "pkg/conversion",
     "pkg/conversion/queryparams",
     "pkg/fields",
@@ -578,7 +495,7 @@
     "pkg/watch",
     "third_party/forked/golang/reflect"
   ]
-  revision = "180eddb345a5be3a157cea1c624700ad5bd27b8f"
+  revision = "302974c03f7e50f16561ba237db776ab93594ef6"
 
 [[projects]]
   name = "k8s.io/client-go"
@@ -614,7 +531,10 @@
     "kubernetes/typed/storage/v1",
     "kubernetes/typed/storage/v1alpha1",
     "kubernetes/typed/storage/v1beta1",
+    "pkg/apis/clientauthentication",
+    "pkg/apis/clientauthentication/v1alpha1",
     "pkg/version",
+    "plugin/pkg/client/auth/exec",
     "rest",
     "rest/watch",
     "tools/auth",
@@ -631,20 +551,15 @@
     "util/cert",
     "util/flowcontrol",
     "util/homedir",
-    "util/integer"
+    "util/integer",
+    "util/retry"
   ]
-  revision = "78700dec6369ba22221b72770783300f143df150"
-  version = "v6.0.0"
-
-[[projects]]
-  branch = "master"
-  name = "k8s.io/kube-openapi"
-  packages = ["pkg/common"]
-  revision = "b3f03f55328800731ce03a164b80973014ecd455"
+  revision = "23781f4d6632d88e869066eaebb743857aa1ef9b"
+  version = "v7.0.0"
 
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "6d21f29335af637692bbb8881f9950edf9a64c595d0782b39d4b56eb404844d5"
+  inputs-digest = "dbbdcbcd4c0e11f040230e43a145f113ed7e67ff2c52b2a5830e117c16a23630"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -13,13 +13,13 @@ ignored = [
 # is unable to match Godep.json automatically so have to specify here.
 [[constraint]]
     name = "k8s.io/client-go"
-    version = "v6.0.0"
+    version = "v7.0.0"
 [[override]]
     name = "k8s.io/apimachinery"
-    revision = "180eddb345a5be3a157cea1c624700ad5bd27b8f"
+    revision = "302974c03f7e50f16561ba237db776ab93594ef6"
 [[override]]
     name = "k8s.io/api"
-    revision = "11147472b7c934c474a2c484af3c0c5210b7a3af"
+    revision = "73d903622b7391f3312dcbac6483fed484e185f8"
 [[override]]
     name = "github.com/apache/thrift"
     revision = "e59b73d3c2bf1c328ccb78e683c0462fa1a473c7"

vendor/github.com/PuerkitoBio/purell/.gitignore

-*.sublime-*
-.DS_Store
-*.swp
-*.swo
-tags

vendor/github.com/PuerkitoBio/purell/.travis.yml

-language: go
-
-go:
-    - 1.4
-    - 1.5
-    - 1.6
-    - tip

vendor/github.com/PuerkitoBio/purell/LICENSE

-Copyright (c) 2012, Martin Angers
-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 the author 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 HOLDER 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.

vendor/github.com/PuerkitoBio/purell/README.md

-# Purell
-
-Purell is a tiny Go library to normalize URLs. It returns a pure URL. Pure-ell. Sanitizer and all. Yeah, I know...
-
-Based on the [wikipedia paper][wiki] and the [RFC 3986 document][rfc].
-
-[![build status](https://secure.travis-ci.org/PuerkitoBio/purell.png)](http://travis-ci.org/PuerkitoBio/purell)
-
-## Install
-
-`go get github.com/PuerkitoBio/purell`
-
-## Changelog
-
-*    **2016-11-14 (v1.1.0)** : IDN: Conform to RFC 5895: Fold character width (thanks to @beeker1121).
-*    **2016-07-27 (v1.0.0)** : Normalize IDN to ASCII (thanks to @zenovich).
-*    **2015-02-08** : Add fix for relative paths issue ([PR #5][pr5]) and add fix for unnecessary encoding of reserved characters ([see issue #7][iss7]).
-*    **v0.2.0** : Add benchmarks, Attempt IDN support.
-*    **v0.1.0** : Initial release.
-
-## Examples
-
-From `example_test.go` (note that in your code, you would import "github.com/PuerkitoBio/purell", and would prefix references to its methods and constants with "purell."):
-
-```go
-package purell
-
-import (
-  "fmt"
-  "net/url"
-)
-
-func ExampleNormalizeURLString() {
-  if normalized, err := NormalizeURLString("hTTp://someWEBsite.com:80/Amazing%3f/url/",
-    FlagLowercaseScheme|FlagLowercaseHost|FlagUppercaseEscapes); err != nil {
-    panic(err)
-  } else {
-    fmt.Print(normalized)
-  }
-  // Output: http://somewebsite.com:80/Amazing%3F/url/
-}
-
-func ExampleMustNormalizeURLString() {
-  normalized := MustNormalizeURLString("hTTpS://someWEBsite.com:443/Amazing%fa/url/",
-    FlagsUnsafeGreedy)
-  fmt.Print(normalized)
-
-  // Output: http://somewebsite.com/Amazing%FA/url
-}
-
-func ExampleNormalizeURL() {
-  if u, err := url.Parse("Http://SomeUrl.com:8080/a/b/.././c///g?c=3&a=1&b=9&c=0#target"); err != nil {
-    panic(err)
-  } else {
-    normalized := NormalizeURL(u, FlagsUsuallySafeGreedy|FlagRemoveDuplicateSlashes|FlagRemoveFragment)
-    fmt.Print(normalized)
-  }
-
-  // Output: http://someurl.com:8080/a/c/g?c=3&a=1&b=9&c=0
-}
-```
-
-## API
-
-As seen in the examples above, purell offers three methods, `NormalizeURLString(string, NormalizationFlags) (string, error)`, `MustNormalizeURLString(string, NormalizationFlags) (string)` and `NormalizeURL(*url.URL, NormalizationFlags) (string)`. They all normalize the provided URL based on the specified flags. Here are the available flags:
-
-```go
-const (
-	// Safe normalizations
-	FlagLowercaseScheme           NormalizationFlags = 1 << iota // HTTP://host -> http://host, applied by default in Go1.1
-	FlagLowercaseHost                                            // http://HOST -> http://host
-	FlagUppercaseEscapes                                         // http://host/t%ef -> http://host/t%EF
-	FlagDecodeUnnecessaryEscapes                                 // http://host/t%41 -> http://host/tA
-	FlagEncodeNecessaryEscapes                                   // http://host/!"#$ -> http://host/%21%22#$
-	FlagRemoveDefaultPort                                        // http://host:80 -> http://host
-	FlagRemoveEmptyQuerySeparator                                // http://host/path? -> http://host/path
-
-	// Usually safe normalizations
-	FlagRemoveTrailingSlash // http://host/path/ -> http://host/path
-	FlagAddTrailingSlash    // http://host/path -> http://host/path/ (should choose only one of these add/remove trailing slash flags)
-	FlagRemoveDotSegments   // http://host/path/./a/b/../c -> http://host/path/a/c
-
-	// Unsafe normalizations
-	FlagRemoveDirectoryIndex   // http://host/path/index.html -> http://host/path/
-	FlagRemoveFragment         // http://host/path#fragment -> http://host/path
-	FlagForceHTTP              // https://host -> http://host
-	FlagRemoveDuplicateSlashes // http://host/path//a///b -> http://host/path/a/b
-	FlagRemoveWWW              // http://www.host/ -> http://host/
-	FlagAddWWW                 // http://host/ -> http://www.host/ (should choose only one of these add/remove WWW flags)
-	FlagSortQuery              // http://host/path?c=3&b=2&a=1&b=1 -> http://host/path?a=1&b=1&b=2&c=3
-
-	// Normalizations not in the wikipedia article, required to cover tests cases
-	// submitted by jehiah
-	FlagDecodeDWORDHost           // http://1113982867 -> http://66.102.7.147
-	FlagDecodeOctalHost           // http://0102.0146.07.0223 -> http://66.102.7.147
-	FlagDecodeHexHost             // http://0x42660793 -> http://66.102.7.147
-	FlagRemoveUnnecessaryHostDots // http://.host../path -> http://host/path
-	FlagRemoveEmptyPortSeparator  // http://host:/path -> http://host/path
-
-	// Convenience set of safe normalizations
-	FlagsSafe NormalizationFlags = FlagLowercaseHost | FlagLowercaseScheme | FlagUppercaseEscapes | FlagDecodeUnnecessaryEscapes | FlagEncodeNecessaryEscapes | FlagRemoveDefaultPort | FlagRemoveEmptyQuerySeparator
-
-	// For convenience sets, "greedy" uses the "remove trailing slash" and "remove www. prefix" flags,
-	// while "non-greedy" uses the "add (or keep) the trailing slash" and "add www. prefix".
-
-	// Convenience set of usually safe normalizations (includes FlagsSafe)
-	FlagsUsuallySafeGreedy    NormalizationFlags = FlagsSafe | FlagRemoveTrailingSlash | FlagRemoveDotSegments
-	FlagsUsuallySafeNonGreedy NormalizationFlags = FlagsSafe | FlagAddTrailingSlash | FlagRemoveDotSegments
-
-	// Convenience set of unsafe normalizations (includes FlagsUsuallySafe)
-	FlagsUnsafeGreedy    NormalizationFlags = FlagsUsuallySafeGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagRemoveWWW | FlagSortQuery
-	FlagsUnsafeNonGreedy NormalizationFlags = FlagsUsuallySafeNonGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagAddWWW | FlagSortQuery
-
-	// Convenience set of all available flags
-	FlagsAllGreedy    = FlagsUnsafeGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
-	FlagsAllNonGreedy = FlagsUnsafeNonGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
-)
-```
-
-For convenience, the set of flags `FlagsSafe`, `FlagsUsuallySafe[Greedy|NonGreedy]`, `FlagsUnsafe[Greedy|NonGreedy]` and `FlagsAll[Greedy|NonGreedy]` are provided for the similarly grouped normalizations on [wikipedia's URL normalization page][wiki]. You can add (using the bitwise OR `|` operator) or remove (using the bitwise AND NOT `&^` operator) individual flags from the sets if required, to build your own custom set.
-
-The [full godoc reference is available on gopkgdoc][godoc].
-
-Some things to note:
-
-*    `FlagDecodeUnnecessaryEscapes`, `FlagEncodeNecessaryEscapes`, `FlagUppercaseEscapes` and `FlagRemoveEmptyQuerySeparator` are always implicitly set, because internally, the URL string is parsed as an URL object, which automatically decodes unnecessary escapes, uppercases and encodes necessary ones, and removes empty query separators (an unnecessary `?` at the end of the url). So this operation cannot **not** be done. For this reason, `FlagRemoveEmptyQuerySeparator` (as well as the other three) has been included in the `FlagsSafe` convenience set, instead of `FlagsUnsafe`, where Wikipedia puts it.
-
-*    The `FlagDecodeUnnecessaryEscapes` decodes the following escapes (*from -> to*):
-    -    %24 -> $
-    -    %26 -> &
-    -    %2B-%3B -> +,-./0123456789:;
-    -    %3D -> =
-    -    %40-%5A -> @ABCDEFGHIJKLMNOPQRSTUVWXYZ
-    -    %5F -> _
-    -    %61-%7A -> abcdefghijklmnopqrstuvwxyz
-    -    %7E -> ~
-
-
-*    When the `NormalizeURL` function is used (passing an URL object), this source URL object is modified (that is, after the call, the URL object will be modified to reflect the normalization).
-
-*    The *replace IP with domain name* normalization (`http://208.77.188.166/ → http://www.example.com/`) is obviously not possible for a library without making some network requests. This is not implemented in purell.
-
-*    The *remove unused query string parameters* and *remove default query parameters* are also not implemented, since this is a very case-specific normalization, and it is quite trivial to do with an URL object.
-
-### Safe vs Usually Safe vs Unsafe
-
-Purell allows you to control the level of risk you take while normalizing an URL. You can aggressively normalize, play it totally safe, or anything in between.
-
-Consider the following URL:
-
-`HTTPS://www.RooT.com/toto/t%45%1f///a/./b/../c/?z=3&w=2&a=4&w=1#invalid`
-
-Normalizing with the `FlagsSafe` gives:
-
-`https://www.root.com/toto/tE%1F///a/./b/../c/?z=3&w=2&a=4&w=1#invalid`
-
-With the `FlagsUsuallySafeGreedy`:
-
-`https://www.root.com/toto/tE%1F///a/c?z=3&w=2&a=4&w=1#invalid`
-
-And with `FlagsUnsafeGreedy`:
-
-`http://root.com/toto/tE%1F/a/c?a=4&w=1&w=2&z=3`
-
-## TODOs
-
-*    Add a class/default instance to allow specifying custom directory index names? At the moment, removing directory index removes `(^|/)((?:default|index)\.\w{1,4})$`.
-
-## Thanks / Contributions
-
-@rogpeppe
-@jehiah
-@opennota
-@pchristopher1275
-@zenovich
-@beeker1121
-
-## License
-
-The [BSD 3-Clause license][bsd].
-
-[bsd]: http://opensource.org/licenses/BSD-3-Clause
-[wiki]: http://en.wikipedia.org/wiki/URL_normalization
-[rfc]: http://tools.ietf.org/html/rfc3986#section-6
-[godoc]: http://go.pkgdoc.org/github.com/PuerkitoBio/purell
-[pr5]: https://github.com/PuerkitoBio/purell/pull/5
-[iss7]: https://github.com/PuerkitoBio/purell/issues/7

vendor/github.com/PuerkitoBio/purell/bench_test.go

-package purell
-
-import (
-	"testing"
-)
-
-var (
-	safeUrl        = "HttPS://..iaMHost..Test:443/paTh^A%ef//./%41PaTH/..//?"
-	usuallySafeUrl = "HttPS://..iaMHost..Test:443/paTh^A%ef//./%41PaTH/../final/"
-	unsafeUrl      = "HttPS://..www.iaMHost..Test:443/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
-	allDWORDUrl    = "HttPS://1113982867:/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
-	allOctalUrl    = "HttPS://0102.0146.07.0223:/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
-	allHexUrl      = "HttPS://0x42660793:/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
-	allCombinedUrl = "HttPS://..0x42660793.:/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
-)
-
-func BenchmarkSafe(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		NormalizeURLString(safeUrl, FlagsSafe)
-	}
-}
-
-func BenchmarkUsuallySafe(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		NormalizeURLString(usuallySafeUrl, FlagsUsuallySafeGreedy)
-	}
-}
-
-func BenchmarkUnsafe(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		NormalizeURLString(unsafeUrl, FlagsUnsafeGreedy)
-	}
-}
-
-func BenchmarkAllDWORD(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		NormalizeURLString(allDWORDUrl, FlagsAllGreedy)
-	}
-}
-
-func BenchmarkAllOctal(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		NormalizeURLString(allOctalUrl, FlagsAllGreedy)
-	}
-}
-
-func BenchmarkAllHex(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		NormalizeURLString(allHexUrl, FlagsAllGreedy)
-	}
-}
-
-func BenchmarkAllCombined(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		NormalizeURLString(allCombinedUrl, FlagsAllGreedy)
-	}
-}

vendor/github.com/PuerkitoBio/purell/example_test.go

-package purell
-
-import (
-	"fmt"
-	"net/url"
-)
-
-func ExampleNormalizeURLString() {
-	if normalized, err := NormalizeURLString("hTTp://someWEBsite.com:80/Amazing%3f/url/",
-		FlagLowercaseScheme|FlagLowercaseHost|FlagUppercaseEscapes); err != nil {
-		panic(err)
-	} else {
-		fmt.Print(normalized)
-	}
-	// Output: http://somewebsite.com:80/Amazing%3F/url/
-}
-
-func ExampleMustNormalizeURLString() {
-	normalized := MustNormalizeURLString("hTTpS://someWEBsite.com:443/Amazing%fa/url/",
-		FlagsUnsafeGreedy)
-	fmt.Print(normalized)
-
-	// Output: http://somewebsite.com/Amazing%FA/url
-}
-
-func ExampleNormalizeURL() {
-	if u, err := url.Parse("Http://SomeUrl.com:8080/a/b/.././c///g?c=3&a=1&b=9&c=0#target"); err != nil {
-		panic(err)
-	} else {
-		normalized := NormalizeURL(u, FlagsUsuallySafeGreedy|FlagRemoveDuplicateSlashes|FlagRemoveFragment)
-		fmt.Print(normalized)
-	}
-
-	// Output: http://someurl.com:8080/a/c/g?c=3&a=1&b=9&c=0
-}

vendor/github.com/PuerkitoBio/purell/urlnorm_test.go

-package purell
-
-import (
-	"testing"
-)
-
-// Test cases merged from PR #1
-// Originally from https://github.com/jehiah/urlnorm/blob/master/test_urlnorm.py
-
-func assertMap(t *testing.T, cases map[string]string, f NormalizationFlags) {
-	for bad, good := range cases {
-		s, e := NormalizeURLString(bad, f)
-		if e != nil {
-			t.Errorf("%s normalizing %v to %v", e.Error(), bad, good)
-		} else {
-			if s != good {
-				t.Errorf("source: %v expected: %v got: %v", bad, good, s)
-			}
-		}
-	}
-}
-
-// This tests normalization to a unicode representation
-// precent escapes for unreserved values are unescaped to their unicode value
-// tests normalization to idna domains
-// test ip word handling, ipv6 address handling, and trailing domain periods
-// in general, this matches google chromes unescaping for things in the address bar.
-// spaces are converted to '+' (perhaphs controversial)
-// http://code.google.com/p/google-url/ probably is another good reference for this approach
-func TestUrlnorm(t *testing.T) {
-	testcases := map[string]string{
-		"http://test.example/?a=%e3%82%82%26": "http://test.example/?a=%e3%82%82%26",
-		//"http://test.example/?a=%e3%82%82%26": "http://test.example/?a=\xe3\x82\x82%26", //should return a unicode character
-		"http://s.xn--q-bga.DE/":    "http://s.xn--q-bga.de/",       //should be in idna format
-		"http://XBLA\u306eXbox.com": "http://xn--xblaxbox-jf4g.com", //test utf8 and unicode
-		"http://президент.рф":       "http://xn--d1abbgf6aiiy.xn--p1ai",
-		"http://ПРЕЗИДЕНТ.РФ":       "http://xn--d1abbgf6aiiy.xn--p1ai",
-		"http://ａｂ￥ヲ￦○.com":         "http://xn--ab-ida8983azmfnvs.com", //test width folding
-		"http://\u00e9.com":         "http://xn--9ca.com",
-		"http://e\u0301.com":        "http://xn--9ca.com",
-		"http://ja.wikipedia.org/wiki/%E3%82%AD%E3%83%A3%E3%82%BF%E3%83%94%E3%83%A9%E3%83%BC%E3%82%B8%E3%83%A3%E3%83%91%E3%83%B3": "http://ja.wikipedia.org/wiki/%E3%82%AD%E3%83%A3%E3%82%BF%E3%83%94%E3%83%A9%E3%83%BC%E3%82%B8%E3%83%A3%E3%83%91%E3%83%B3",
-		//"http://ja.wikipedia.org/wiki/%E3%82%AD%E3%83%A3%E3%82%BF%E3%83%94%E3%83%A9%E3%83%BC%E3%82%B8%E3%83%A3%E3%83%91%E3%83%B3": "http://ja.wikipedia.org/wiki/\xe3\x82\xad\xe3\x83\xa3\xe3\x82\xbf\xe3\x83\x94\xe3\x83\xa9\xe3\x83\xbc\xe3\x82\xb8\xe3\x83\xa3\xe3\x83\x91\xe3\x83\xb3",
-
-		"http://test.example/\xe3\x82\xad": "http://test.example/%E3%82%AD",
-		//"http://test.example/\xe3\x82\xad":              "http://test.example/\xe3\x82\xad",
-		"http://test.example/?p=%23val#test-%23-val%25": "http://test.example/?p=%23val#test-%23-val%25", //check that %23 (#) is not escaped where it shouldn't be
-
-		"http://test.domain/I%C3%B1t%C3%ABrn%C3%A2ti%C3%B4n%EF%BF%BDliz%C3%A6ti%C3%B8n": "http://test.domain/I%C3%B1t%C3%ABrn%C3%A2ti%C3%B4n%EF%BF%BDliz%C3%A6ti%C3%B8n",
-		//"http://test.domain/I%C3%B1t%C3%ABrn%C3%A2ti%C3%B4n%EF%BF%BDliz%C3%A6ti%C3%B8n": "http://test.domain/I\xc3\xb1t\xc3\xabrn\xc3\xa2ti\xc3\xb4n\xef\xbf\xbdliz\xc3\xa6ti\xc3\xb8n",
-	}
-
-	assertMap(t, testcases, FlagsSafe|FlagRemoveDotSegments)
-}

vendor/github.com/PuerkitoBio/urlesc/.travis.yml

-language: go
-
-go:
-  - 1.4.x
-  - 1.5.x
-  - 1.6.x
-  - 1.7.x
-  - 1.8.x
-  - tip
-
-install:
-  - go build .
-
-script:
-  - go test -v

vendor/github.com/PuerkitoBio/urlesc/README.md

-urlesc [![Build Status](https://travis-ci.org/PuerkitoBio/urlesc.svg?branch=master)](https://travis-ci.org/PuerkitoBio/urlesc) [![GoDoc](http://godoc.org/github.com/PuerkitoBio/urlesc?status.svg)](http://godoc.org/github.com/PuerkitoBio/urlesc)
-======
-
-Package urlesc implements query escaping as per RFC 3986.
-
-It contains some parts of the net/url package, modified so as to allow
-some reserved characters incorrectly escaped by net/url (see [issue 5684](https://github.com/golang/go/issues/5684)).
-
-## Install
-
-    go get github.com/PuerkitoBio/urlesc
-
-## License
-
-Go license (BSD-3-Clause)
-

vendor/github.com/PuerkitoBio/urlesc/urlesc.go

-// Copyright 2009 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 urlesc implements query escaping as per RFC 3986.
-// It contains some parts of the net/url package, modified so as to allow
-// some reserved characters incorrectly escaped by net/url.
-// See https://github.com/golang/go/issues/5684
-package urlesc
-
-import (
-	"bytes"
-	"net/url"
-	"strings"
-)
-
-type encoding int
-
-const (
-	encodePath encoding = 1 + iota
-	encodeUserPassword
-	encodeQueryComponent
-	encodeFragment
-)
-
-// Return true if the specified character should be escaped when
-// appearing in a URL string, according to RFC 3986.
-func shouldEscape(c byte, mode encoding) bool {
-	// §2.3 Unreserved characters (alphanum)
-	if 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' {
-		return false
-	}
-
-	switch c {
-	case '-', '.', '_', '~': // §2.3 Unreserved characters (mark)
-		return false
-
-	// §2.2 Reserved characters (reserved)
-	case ':', '/', '?', '#', '[', ']', '@', // gen-delims
-		'!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=': // sub-delims
-		// Different sections of the URL allow a few of
-		// the reserved characters to appear unescaped.
-		switch mode {
-		case encodePath: // §3.3
-			// The RFC allows sub-delims and : @.
-			// '/', '[' and ']' can be used to assign meaning to individual path
-			// segments.  This package only manipulates the path as a whole,
-			// so we allow those as well.  That leaves only ? and # to escape.
-			return c == '?' || c == '#'
-
-		case encodeUserPassword: // §3.2.1
-			// The RFC allows : and sub-delims in
-			// userinfo.  The parsing of userinfo treats ':' as special so we must escape
-			// all the gen-delims.
-			return c == ':' || c == '/' || c == '?' || c == '#' || c == '[' || c == ']' || c == '@'
-
-		case encodeQueryComponent: // §3.4
-			// The RFC allows / and ?.
-			return c != '/' && c != '?'
-
-		case encodeFragment: // §4.1
-			// The RFC text is silent but the grammar allows
-			// everything, so escape nothing but #
-			return c == '#'
-		}
-	}
-
-	// Everything else must be escaped.
-	return true
-}
-
-// QueryEscape escapes the string so it can be safely placed
-// inside a URL query.
-func QueryEscape(s string) string {
-	return escape(s, encodeQueryComponent)
-}
-
-func escape(s string, mode encoding) string {
-	spaceCount, hexCount := 0, 0
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		if shouldEscape(c, mode) {
-			if c == ' ' && mode == encodeQueryComponent {
-				spaceCount++
-			} else {
-				hexCount++
-			}
-		}
-	}
-
-	if spaceCount == 0 && hexCount == 0 {
-		return s
-	}
-
-	t := make([]byte, len(s)+2*hexCount)
-	j := 0
-	for i := 0; i < len(s); i++ {
-		switch c := s[i]; {
-		case c == ' ' && mode == encodeQueryComponent:
-			t[j] = '+'
-			j++
-		case shouldEscape(c, mode):
-			t[j] = '%'
-			t[j+1] = "0123456789ABCDEF"[c>>4]
-			t[j+2] = "0123456789ABCDEF"[c&15]
-			j += 3
-		default:
-			t[j] = s[i]
-			j++
-		}
-	}
-	return string(t)
-}
-
-var uiReplacer = strings.NewReplacer(
-	"%21", "!",
-	"%27", "'",
-	"%28", "(",
-	"%29", ")",
-	"%2A", "*",
-)
-
-// unescapeUserinfo unescapes some characters that need not to be escaped as per RFC3986.
-func unescapeUserinfo(s string) string {
-	return uiReplacer.Replace(s)
-}
-
-// Escape reassembles the URL into a valid URL string.
-// The general form of the result is one of:
-//
-//	scheme:opaque
-//	scheme://userinfo@host/path?query#fragment
-//
-// If u.Opaque is non-empty, String uses the first form;
-// otherwise it uses the second form.
-//
-// In the second form, the following rules apply:
-//	- if u.Scheme is empty, scheme: is omitted.
-//	- if u.User is nil, userinfo@ is omitted.
-//	- if u.Host is empty, host/ is omitted.
-//	- if u.Scheme and u.Host are empty and u.User is nil,
-//	   the entire scheme://userinfo@host/ is omitted.
-//	- if u.Host is non-empty and u.Path begins with a /,
-//	   the form host/path does not add its own /.
-//	- if u.RawQuery is empty, ?query is omitted.
-//	- if u.Fragment is empty, #fragment is omitted.
-func Escape(u *url.URL) string {
-	var buf bytes.Buffer
-	if u.Scheme != "" {
-		buf.WriteString(u.Scheme)
-		buf.WriteByte(':')
-	}
-	if u.Opaque != "" {
-		buf.WriteString(u.Opaque)
-	} else {
-		if u.Scheme != "" || u.Host != "" || u.User != nil {
-			buf.WriteString("//")
-			if ui := u.User; ui != nil {
-				buf.WriteString(unescapeUserinfo(ui.String()))
-				buf.WriteByte('@')
-			}
-			if h := u.Host; h != "" {
-				buf.WriteString(h)
-			}
-		}
-		if u.Path != "" && u.Path[0] != '/' && u.Host != "" {
-			buf.WriteByte('/')
-		}
-		buf.WriteString(escape(u.Path, encodePath))
-	}
-	if u.RawQuery != "" {
-		buf.WriteByte('?')
-		buf.WriteString(u.RawQuery)
-	}
-	if u.Fragment != "" {
-		buf.WriteByte('#')
-		buf.WriteString(escape(u.Fragment, encodeFragment))
-	}
-	return buf.String()
-}

vendor/github.com/emicklei/go-restful/.gitignore

-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-
-restful.html
-
-*.out
-
-tmp.prof
-
-go-restful.test
-
-examples/restful-basic-authentication
-
-examples/restful-encoding-filter
-
-examples/restful-filters
-
-examples/restful-hello-world
-
-examples/restful-resource-functions
-
-examples/restful-serve-static
-
-examples/restful-user-service
-
-*.DS_Store
-examples/restful-user-resource
-
-examples/restful-multi-containers
-
-examples/restful-form-handling
-
-examples/restful-CORS-filter
-
-examples/restful-options-filter
-
-examples/restful-curly-router
-
-examples/restful-cpuprofiler-service
-
-examples/restful-pre-post-filters
-
-curly.prof
-
-examples/restful-NCSA-logging
-
-examples/restful-html-template
-
-s.html
-restful-path-tail

vendor/github.com/emicklei/go-restful/.travis.yml

-language: go
-
-go:
-  - 1.x
-
-script: go test -v
\ No newline at end of file

vendor/github.com/emicklei/go-restful/CHANGES.md

-Change history of go-restful
-=
-v2.6.1
-- add JSONNewDecoderFunc to allow custom JSON Decoder usage (go 1.10+)
-
-v2.6.0
-- Make JSR 311 routing and path param processing consistent
-- Adding description to RouteBuilder.Reads()
-- Update example for Swagger12 and OpenAPI
-
-2017-09-13
-- added route condition functions using `.If(func)` in route building.
-
-2017-02-16
-- solved issue #304, make operation names unique
-
-2017-01-30
- 
-	[IMPORTANT] For swagger users, change your import statement to:	
-	swagger "github.com/emicklei/go-restful-swagger12"
-
-- moved swagger 1.2 code to go-restful-swagger12
-- created TAG 2.0.0
-
-2017-01-27
-
-- remove defer request body close
-- expose Dispatch for testing filters and Routefunctions
-- swagger response model cannot be array 
-- created TAG 1.0.0
-
-2016-12-22
-
-- (API change) Remove code related to caching request content. Removes SetCacheReadEntity(doCache bool)
-
-2016-11-26
-
-- Default change! now use CurlyRouter (was RouterJSR311)
-- Default change! no more caching of request content
-- Default change! do not recover from panics
-
-2016-09-22
-
-- fix the DefaultRequestContentType feature
-
-2016-02-14
-
-- take the qualify factor of the Accept header mediatype into account when deciding the contentype of the response
-- add constructors for custom entity accessors for xml and json 
-
-2015-09-27
-
-- rename new WriteStatusAnd... to WriteHeaderAnd... for consistency
-
-2015-09-25
-
-- fixed problem with changing Header after WriteHeader (issue 235)
-
-2015-09-14
-
-- changed behavior of WriteHeader (immediate write) and WriteEntity (no status write)
-- added support for custom EntityReaderWriters.
-
-2015-08-06
-
-- add support for reading entities from compressed request content
-- use sync.Pool for compressors of http response and request body
-- add Description to Parameter for documentation in Swagger UI
-
-2015-03-20
-
-- add configurable logging
-
-2015-03-18
-
-- if not specified, the Operation is derived from the Route function
-
-2015-03-17
-
-- expose Parameter creation functions
-- make trace logger an interface
-- fix OPTIONSFilter
-- customize rendering of ServiceError
-- JSR311 router now handles wildcards
-- add Notes to Route
-
-2014-11-27
-
-- (api add) PrettyPrint per response. (as proposed in #167)
-
-2014-11-12
-
-- (api add) ApiVersion(.) for documentation in Swagger UI
-
-2014-11-10
-
-- (api change) struct fields tagged with "description" show up in Swagger UI
-
-2014-10-31
-
-- (api change) ReturnsError -> Returns
-- (api add)    RouteBuilder.Do(aBuilder) for DRY use of RouteBuilder
-- fix swagger nested structs
-- sort Swagger response messages by code
-
-2014-10-23
-
-- (api add) ReturnsError allows you to document Http codes in swagger
-- fixed problem with greedy CurlyRouter
-- (api add) Access-Control-Max-Age in CORS
-- add tracing functionality (injectable) for debugging purposes
-- support JSON parse 64bit int 
-- fix empty parameters for swagger
-- WebServicesUrl is now optional for swagger
-- fixed duplicate AccessControlAllowOrigin in CORS
-- (api change) expose ServeMux in container
-- (api add) added AllowedDomains in CORS
-- (api add) ParameterNamed for detailed documentation
-
-2014-04-16
-
-- (api add) expose constructor of Request for testing.
-
-2014-06-27
-
-- (api add) ParameterNamed gives access to a Parameter definition and its data (for further specification).
-- (api add) SetCacheReadEntity allow scontrol over whether or not the request body is being cached (default true for compatibility reasons).
-
-2014-07-03
-
-- (api add) CORS can be configured with a list of allowed domains
-
-2014-03-12
-
-- (api add) Route path parameters can use wildcard or regular expressions. (requires CurlyRouter)
-
-2014-02-26
-
-- (api add) Request now provides information about the matched Route, see method SelectedRoutePath 
-
-2014-02-17
-
-- (api change) renamed parameter constants (go-lint checks)
-
-2014-01-10
-
-- (api add) support for CloseNotify, see http://golang.org/pkg/net/http/#CloseNotifier
-
-2014-01-07
-
-- (api change) Write* methods in Response now return the error or nil.
-- added example of serving HTML from a Go template.
-- fixed comparing Allowed headers in CORS (is now case-insensitive)
-
-2013-11-13
-
-- (api add) Response knows how many bytes are written to the response body.
-
-2013-10-29
-
-- (api add) RecoverHandler(handler RecoverHandleFunction) to change how panic recovery is handled. Default behavior is to log and return a stacktrace. This may be a security issue as it exposes sourcecode information.
-
-2013-10-04
-
-- (api add) Response knows what HTTP status has been written
-- (api add) Request can have attributes (map of string->interface, also called request-scoped variables
-
-2013-09-12
-
-- (api change) Router interface simplified
-- Implemented CurlyRouter, a Router that does not use|allow regular expressions in paths
-
-2013-08-05
- - add OPTIONS support
- - add CORS support
-
-2013-08-27
-
-- fixed some reported issues (see github)
-- (api change) deprecated use of WriteError; use WriteErrorString instead
-
-2014-04-15
-
-- (fix) v1.0.1 tag: fix Issue 111: WriteErrorString
-
-2013-08-08
-
-- (api add) Added implementation Container: a WebServices collection with its own http.ServeMux allowing multiple endpoints per program. Existing uses of go-restful will register their services to the DefaultContainer.
-- (api add) the swagger package has be extended to have a UI per container.
-- if panic is detected then a small stack trace is printed (thanks to runner-mei)
-- (api add) WriteErrorString to Response
-
-Important API changes:
-
-- (api remove) package variable DoNotRecover no longer works ; use restful.DefaultContainer.DoNotRecover(true) instead.
-- (api remove) package variable EnableContentEncoding no longer works ; use restful.DefaultContainer.EnableContentEncoding(true) instead.
- 
- 
-2013-07-06
-
-- (api add) Added support for response encoding (gzip and deflate(zlib)). This feature is disabled on default (for backwards compatibility). Use restful.EnableContentEncoding = true in your initialization to enable this feature.
-
-2013-06-19
-
-- (improve) DoNotRecover option, moved request body closer, improved ReadEntity
-
-2013-06-03
-
-- (api change) removed Dispatcher interface, hide PathExpression
-- changed receiver names of type functions to be more idiomatic Go
-
-2013-06-02
-
-- (optimize) Cache the RegExp compilation of Paths.
-
-2013-05-22
-	
-- (api add) Added support for request/response filter functions
-
-2013-05-18
-
-
-- (api add) Added feature to change the default Http Request Dispatch function (travis cline)
-- (api change) Moved Swagger Webservice to swagger package (see example restful-user)
-
-[2012-11-14 .. 2013-05-18>
- 
-- See https://github.com/emicklei/go-restful/commits
-
-2012-11-14
-
-- Initial commit
-
-

vendor/github.com/emicklei/go-restful/LICENSE

-Copyright (c) 2012,2013 Ernest Micklei
-
-MIT License
-
-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.
\ No newline at end of file

vendor/github.com/emicklei/go-restful/Makefile

-all: test
-
-test:
-	go test -v .
-
-ex:
-	cd examples && ls *.go | xargs go build -o /tmp/ignore
\ No newline at end of file

vendor/github.com/emicklei/go-restful/README.md

-go-restful
-==========
-package for building REST-style Web Services using Google Go
-
-[![Build Status](https://travis-ci.org/emicklei/go-restful.png)](https://travis-ci.org/emicklei/go-restful)
-[![Go Report Card](https://goreportcard.com/badge/github.com/emicklei/go-restful)](https://goreportcard.com/report/github.com/emicklei/go-restful)
-[![GoDoc](https://godoc.org/github.com/emicklei/go-restful?status.svg)](https://godoc.org/github.com/emicklei/go-restful)
-
-- [Code examples](https://github.com/emicklei/go-restful/tree/master/examples)
-
-REST asks developers to use HTTP methods explicitly and in a way that's consistent with the protocol definition. This basic REST design principle establishes a one-to-one mapping between create, read, update, and delete (CRUD) operations and HTTP methods. According to this mapping:
-
-- GET = Retrieve a representation of a resource
-- POST = Create if you are sending content to the server to create a subordinate of the specified resource collection, using some server-side algorithm.
-- PUT = Create if you are sending the full content of the specified resource (URI).
-- PUT = Update if you are updating the full content of the specified resource.
-- DELETE = Delete if you are requesting the server to delete the resource
-- PATCH = Update partial content of a resource
-- OPTIONS = Get information about the communication options for the request URI
-    
-### Example
-
-```Go
-ws := new(restful.WebService)
-ws.
-	Path("/users").
-	Consumes(restful.MIME_XML, restful.MIME_JSON).
-	Produces(restful.MIME_JSON, restful.MIME_XML)
-
-ws.Route(ws.GET("/{user-id}").To(u.findUser).
-	Doc("get a user").
-	Param(ws.PathParameter("user-id", "identifier of the user").DataType("string")).
-	Writes(User{}))		
-...
-	
-func (u UserResource) findUser(request *restful.Request, response *restful.Response) {
-	id := request.PathParameter("user-id")
-	...
-}
-```
-	
-[Full API of a UserResource](https://github.com/emicklei/go-restful/tree/master/examples/restful-user-resource.go) 
-		
-### Features
-
-- Routes for request → function mapping with path parameter (e.g. {id}) support
-- Configurable router:
-	- (default) Fast routing algorithm that allows static elements, regular expressions and dynamic parameters in the URL path (e.g. /meetings/{id} or /static/{subpath:*}
-	- Routing algorithm after [JSR311](http://jsr311.java.net/nonav/releases/1.1/spec/spec.html) that is implemented using (but does **not** accept) regular expressions
-- Request API for reading structs from JSON/XML and accesing parameters (path,query,header)
-- Response API for writing structs to JSON/XML and setting headers
-- Customizable encoding using EntityReaderWriter registration
-- Filters for intercepting the request → response flow on Service or Route level
-- Request-scoped variables using attributes
-- Containers for WebServices on different HTTP endpoints
-- Content encoding (gzip,deflate) of request and response payloads
-- Automatic responses on OPTIONS (using a filter)
-- Automatic CORS request handling (using a filter)
-- API declaration for Swagger UI ([go-restful-openapi](https://github.com/emicklei/go-restful-openapi), see [go-restful-swagger12](https://github.com/emicklei/go-restful-swagger12))
-- Panic recovery to produce HTTP 500, customizable using RecoverHandler(...)
-- Route errors produce HTTP 404/405/406/415 errors, customizable using ServiceErrorHandler(...)
-- Configurable (trace) logging
-- Customizable gzip/deflate readers and writers using CompressorProvider registration
-
-## How to customize
-There are several hooks to customize the behavior of the go-restful package.
-
-- Router algorithm
-- Panic recovery
-- JSON decoder
-- Trace logging
-- Compression
-- Encoders for other serializers
-
-TODO: write examples of these.
-
-## Resources
-
-- [Example posted on blog](http://ernestmicklei.com/2012/11/go-restful-first-working-example/)
-- [Design explained on blog](http://ernestmicklei.com/2012/11/go-restful-api-design/)
-- [sourcegraph](https://sourcegraph.com/github.com/emicklei/go-restful)
-- [showcase: Zazkia - tcp proxy for testing resiliency](https://github.com/emicklei/zazkia)
-- [showcase: Mora - MongoDB REST Api server](https://github.com/emicklei/mora)
-
-Type ```git shortlog -s``` for a full list of contributors.
-
-© 2012 - 2018, http://ernestmicklei.com. MIT License. Contributions are welcome.

vendor/github.com/emicklei/go-restful/Srcfile

-{"SkipDirs": ["examples"]}

vendor/github.com/emicklei/go-restful/bench_curly_test.go

-package restful
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func setupCurly(container *Container) []string {
-	wsCount := 26
-	rtCount := 26
-	urisCurly := []string{}
-
-	container.Router(CurlyRouter{})
-	for i := 0; i < wsCount; i++ {
-		root := fmt.Sprintf("/%s/{%s}/", string(i+97), string(i+97))
-		ws := new(WebService).Path(root)
-		for j := 0; j < rtCount; j++ {
-			sub := fmt.Sprintf("/%s2/{%s2}", string(j+97), string(j+97))
-			ws.Route(ws.GET(sub).Consumes("application/xml").Produces("application/xml").To(echoCurly))
-		}
-		container.Add(ws)
-		for _, each := range ws.Routes() {
-			urisCurly = append(urisCurly, "http://bench.com"+each.Path)
-		}
-	}
-	return urisCurly
-}
-
-func echoCurly(req *Request, resp *Response) {}
-
-func BenchmarkManyCurly(b *testing.B) {
-	container := NewContainer()
-	urisCurly := setupCurly(container)
-	b.ResetTimer()
-	for t := 0; t < b.N; t++ {
-		for r := 0; r < 1000; r++ {
-			for _, each := range urisCurly {
-				sendNoReturnTo(each, container, t)
-			}
-		}
-	}
-}
-
-func sendNoReturnTo(address string, container *Container, t int) {
-	httpRequest, _ := http.NewRequest("GET", address, nil)
-	httpRequest.Header.Set("Accept", "application/xml")
-	httpWriter := httptest.NewRecorder()
-	container.dispatch(httpWriter, httpRequest)
-}

vendor/github.com/emicklei/go-restful/bench_test.go

-package restful
-
-import (
-	"fmt"
-	"io"
-	"testing"
-)
-
-var uris = []string{}
-
-func setup(container *Container) {
-	wsCount := 26
-	rtCount := 26
-
-	for i := 0; i < wsCount; i++ {
-		root := fmt.Sprintf("/%s/{%s}/", string(i+97), string(i+97))
-		ws := new(WebService).Path(root)
-		for j := 0; j < rtCount; j++ {
-			sub := fmt.Sprintf("/%s2/{%s2}", string(j+97), string(j+97))
-			ws.Route(ws.GET(sub).To(echo))
-		}
-		container.Add(ws)
-		for _, each := range ws.Routes() {
-			uris = append(uris, "http://bench.com"+each.Path)
-		}
-	}
-}
-
-func echo(req *Request, resp *Response) {
-	io.WriteString(resp.ResponseWriter, "echo")
-}
-
-func BenchmarkMany(b *testing.B) {
-	container := NewContainer()
-	setup(container)
-	b.ResetTimer()
-	for t := 0; t < b.N; t++ {
-		for _, each := range uris {
-			// println(each)
-			sendItTo(each, container)
-		}
-	}
-}

vendor/github.com/emicklei/go-restful/bench_test.sh

-#go test -run=none -file bench_test.go -test.bench . -cpuprofile=bench_test.out
-
-go test -c
-./go-restful.test -test.run=none -test.cpuprofile=tmp.prof -test.bench=BenchmarkMany
-./go-restful.test -test.run=none -test.cpuprofile=curly.prof -test.bench=BenchmarkManyCurly
-
-#go tool pprof go-restful.test tmp.prof
-go tool pprof go-restful.test curly.prof
-
-

vendor/github.com/emicklei/go-restful/compress.go

-package restful
-
-// Copyright 2013 Ernest Micklei. All rights reserved.
-// Use of this source code is governed by a license
-// that can be found in the LICENSE file.
-
-import (
-	"bufio"
-	"compress/gzip"
-	"compress/zlib"
-	"errors"
-	"io"
-	"net"
-	"net/http"
-	"strings"
-)
-
-// OBSOLETE : use restful.DefaultContainer.EnableContentEncoding(true) to change this setting.
-var EnableContentEncoding = false
-
-// CompressingResponseWriter is a http.ResponseWriter that can perform content encoding (gzip and zlib)
-type CompressingResponseWriter struct {
-	writer     http.ResponseWriter
-	compressor io.WriteCloser
-	encoding   string
-}
-
-// Header is part of http.ResponseWriter interface
-func (c *CompressingResponseWriter) Header() http.Header {
-	return c.writer.Header()
-}
-
-// WriteHeader is part of http.ResponseWriter interface
-func (c *CompressingResponseWriter) WriteHeader(status int) {
-	c.writer.WriteHeader(status)
-}
-
-// Write is part of http.ResponseWriter interface
-// It is passed through the compressor
-func (c *CompressingResponseWriter) Write(bytes []byte) (int, error) {
-	if c.isCompressorClosed() {
-		return -1, errors.New("Compressing error: tried to write data using closed compressor")
-	}
-	return c.compressor.Write(bytes)
-}
-
-// CloseNotify is part of http.CloseNotifier interface
-func (c *CompressingResponseWriter) CloseNotify() <-chan bool {
-	return c.writer.(http.CloseNotifier).CloseNotify()
-}
-
-// Close the underlying compressor
-func (c *CompressingResponseWriter) Close() error {
-	if c.isCompressorClosed() {
-		return errors.New("Compressing error: tried to close already closed compressor")
-	}
-
-	c.compressor.Close()
-	if ENCODING_GZIP == c.encoding {
-		currentCompressorProvider.ReleaseGzipWriter(c.compressor.(*gzip.Writer))
-	}
-	if ENCODING_DEFLATE == c.encoding {
-		currentCompressorProvider.ReleaseZlibWriter(c.compressor.(*zlib.Writer))
-	}
-	// gc hint needed?
-	c.compressor = nil
-	return nil
-}
-
-func (c *CompressingResponseWriter) isCompressorClosed() bool {
-	return nil == c.compressor
-}
-
-// Hijack implements the Hijacker interface
-// This is especially useful when combining Container.EnabledContentEncoding
-// in combination with websockets (for instance gorilla/websocket)
-func (c *CompressingResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	hijacker, ok := c.writer.(http.Hijacker)
-	if !ok {
-		return nil, nil, errors.New("ResponseWriter doesn't support Hijacker interface")
-	}
-	return hijacker.Hijack()
-}
-
-// WantsCompressedResponse reads the Accept-Encoding header to see if and which encoding is requested.
-func wantsCompressedResponse(httpRequest *http.Request) (bool, string) {
-	header := httpRequest.Header.Get(HEADER_AcceptEncoding)
-	gi := strings.Index(header, ENCODING_GZIP)
-	zi := strings.Index(header, ENCODING_DEFLATE)
-	// use in order of appearance
-	if gi == -1 {
-		return zi != -1, ENCODING_DEFLATE
-	} else if zi == -1 {
-		return gi != -1, ENCODING_GZIP
-	} else {
-		if gi < zi {
-			return true, ENCODING_GZIP
-		}
-		return true, ENCODING_DEFLATE
-	}
-}
-
-// NewCompressingResponseWriter create a CompressingResponseWriter for a known encoding = {gzip,deflate}
-func NewCompressingResponseWriter(httpWriter http.ResponseWriter, encoding string) (*CompressingResponseWriter, error) {
-	httpWriter.Header().Set(HEADER_ContentEncoding, encoding)
-	c := new(CompressingResponseWriter)
-	c.writer = httpWriter
-	var err error
-	if ENCODING_GZIP == encoding {
-		w := currentCompressorProvider.AcquireGzipWriter()
-		w.Reset(httpWriter)
-		c.compressor = w
-		c.encoding = ENCODING_GZIP
-	} else if ENCODING_DEFLATE == encoding {
-		w := currentCompressorProvider.AcquireZlibWriter()
-		w.Reset(httpWriter)
-		c.compressor = w
-		c.encoding = ENCODING_DEFLATE
-	} else {
-		return nil, errors.New("Unknown encoding:" + encoding)
-	}
-	return c, err
-}

vendor/github.com/emicklei/go-restful/compress_test.go

-package restful
-
-import (
-	"bytes"
-	"compress/gzip"
-	"compress/zlib"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-// go test -v -test.run TestGzip ...restful
-func TestGzip(t *testing.T) {
-	EnableContentEncoding = true
-	httpRequest, _ := http.NewRequest("GET", "/test", nil)
-	httpRequest.Header.Set("Accept-Encoding", "gzip,deflate")
-	httpWriter := httptest.NewRecorder()
-	wanted, encoding := wantsCompressedResponse(httpRequest)
-	if !wanted {
-		t.Fatal("should accept gzip")
-	}
-	if encoding != "gzip" {
-		t.Fatal("expected gzip")
-	}
-	c, err := NewCompressingResponseWriter(httpWriter, encoding)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	c.Write([]byte("Hello World"))
-	c.Close()
-	if httpWriter.Header().Get("Content-Encoding") != "gzip" {
-		t.Fatal("Missing gzip header")
-	}
-	reader, err := gzip.NewReader(httpWriter.Body)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	data, err := ioutil.ReadAll(reader)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if got, want := string(data), "Hello World"; got != want {
-		t.Errorf("got %v want %v", got, want)
-	}
-}
-
-func TestDeflate(t *testing.T) {
-	EnableContentEncoding = true
-	httpRequest, _ := http.NewRequest("GET", "/test", nil)
-	httpRequest.Header.Set("Accept-Encoding", "deflate,gzip")
-	httpWriter := httptest.NewRecorder()
-	wanted, encoding := wantsCompressedResponse(httpRequest)
-	if !wanted {
-		t.Fatal("should accept deflate")
-	}
-	if encoding != "deflate" {
-		t.Fatal("expected deflate")
-	}
-	c, err := NewCompressingResponseWriter(httpWriter, encoding)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	c.Write([]byte("Hello World"))
-	c.Close()
-	if httpWriter.Header().Get("Content-Encoding") != "deflate" {
-		t.Fatal("Missing deflate header")
-	}
-	reader, err := zlib.NewReader(httpWriter.Body)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	data, err := ioutil.ReadAll(reader)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if got, want := string(data), "Hello World"; got != want {
-		t.Errorf("got %v want %v", got, want)
-	}
-}
-
-func TestGzipDecompressRequestBody(t *testing.T) {
-	b := new(bytes.Buffer)
-	w := newGzipWriter()
-	w.Reset(b)
-	io.WriteString(w, `{"msg":"hi"}`)
-	w.Flush()
-	w.Close()
-
-	req := new(Request)
-	httpRequest, _ := http.NewRequest("GET", "/", bytes.NewReader(b.Bytes()))
-	httpRequest.Header.Set("Content-Type", "application/json")
-	httpRequest.Header.Set("Content-Encoding", "gzip")
-	req.Request = httpRequest
-
-	doc := make(map[string]interface{})
-	req.ReadEntity(&doc)
-
-	if got, want := doc["msg"], "hi"; got != want {
-		t.Errorf("got %v want %v", got, want)
-	}
-}
-
-func TestZlibDecompressRequestBody(t *testing.T) {
-	b := new(bytes.Buffer)
-	w := newZlibWriter()
-	w.Reset(b)
-	io.WriteString(w, `{"msg":"hi"}`)
-	w.Flush()
-	w.Close()
-
-	req := new(Request)
-	httpRequest, _ := http.NewRequest("GET", "/", bytes.NewReader(b.Bytes()))
-	httpRequest.Header.Set("Content-Type", "application/json")
-	httpRequest.Header.Set("Content-Encoding", "deflate")
-	req.Request = httpRequest
-
-	doc := make(map[string]interface{})
-	req.ReadEntity(&doc)
-
-	if got, want := doc["msg"], "hi"; got != want {
-		t.Errorf("got %v want %v", got, want)
-	}
-}

vendor/github.com/emicklei/go-restful/compressor_cache.go

-package restful
-
-// Copyright 2015 Ernest Micklei. All rights reserved.
-// Use of this source code is governed by a license
-// that can be found in the LICENSE file.
-
-import (
-	"compress/gzip"
-	"compress/zlib"
-)
-
-// BoundedCachedCompressors is a CompressorProvider that uses a cache with a fixed amount
-// of writers and readers (resources).
-// If a new resource is acquired and all are in use, it will return a new unmanaged resource.
-type BoundedCachedCompressors struct {
-	gzipWriters     chan *gzip.Writer
-	gzipReaders     chan *gzip.Reader
-	zlibWriters     chan *zlib.Writer
-	writersCapacity int
-	readersCapacity int
-}
-
-// NewBoundedCachedCompressors returns a new, with filled cache,  BoundedCachedCompressors.
-func NewBoundedCachedCompressors(writersCapacity, readersCapacity int) *BoundedCachedCompressors {
-	b := &BoundedCachedCompressors{
-		gzipWriters:     make(chan *gzip.Writer, writersCapacity),
-		gzipReaders:     make(chan *gzip.Reader, readersCapacity),
-		zlibWriters:     make(chan *zlib.Writer, writersCapacity),
-		writersCapacity: writersCapacity,
-		readersCapacity: readersCapacity,
-	}
-	for ix := 0; ix < writersCapacity; ix++ {
-		b.gzipWriters <- newGzipWriter()
-		b.zlibWriters <- newZlibWriter()
-	}
-	for ix := 0; ix < readersCapacity; ix++ {
-		b.gzipReaders <- newGzipReader()
-	}
-	return b
-}
-
-// AcquireGzipWriter returns an resettable *gzip.Writer. Needs to be released.
-func (b *BoundedCachedCompressors) AcquireGzipWriter() *gzip.Writer {
-	var writer *gzip.Writer
-	select {
-	case writer, _ = <-b.gzipWriters:
-	default:
-		// return a new unmanaged one
-		writer = newGzipWriter()
-	}
-	return writer
-}
-
-// ReleaseGzipWriter accepts a writer (does not have to be one that was cached)
-// only when the cache has room for it. It will ignore it otherwise.
-func (b *BoundedCachedCompressors) ReleaseGzipWriter(w *gzip.Writer) {
-	// forget the unmanaged ones
-	if len(b.gzipWriters) < b.writersCapacity {
-		b.gzipWriters <- w
-	}
-}
-
-// AcquireGzipReader returns a *gzip.Reader. Needs to be released.
-func (b *BoundedCachedCompressors) AcquireGzipReader() *gzip.Reader {
-	var reader *gzip.Reader
-	select {
-	case reader, _ = <-b.gzipReaders:
-	default:
-		// return a new unmanaged one
-		reader = newGzipReader()
-	}
-	return reader
-}
-
-// ReleaseGzipReader accepts a reader (does not have to be one that was cached)
-// only when the cache has room for it. It will ignore it otherwise.
-func (b *BoundedCachedCompressors) ReleaseGzipReader(r *gzip.Reader) {
-	// forget the unmanaged ones
-	if len(b.gzipReaders) < b.readersCapacity {
-		b.gzipReaders <- r
-	}
-}
-
-// AcquireZlibWriter returns an resettable *zlib.Writer. Needs to be released.
-func (b *BoundedCachedCompressors) AcquireZlibWriter() *zlib.Writer {
-	var writer *zlib.Writer
-	select {
-	case writer, _ = <-b.zlibWriters:
-	default:
-		// return a new unmanaged one
-		writer = newZlibWriter()
-	}
-	return writer
-}
-
-// ReleaseZlibWriter accepts a writer (does not have to be one that was cached)
-// only when the cache has room for it. It will ignore it otherwise.
-func (b *BoundedCachedCompressors) ReleaseZlibWriter(w *zlib.Writer) {
-	// forget the unmanaged ones
-	if len(b.zlibWriters) < b.writersCapacity {
-		b.zlibWriters <- w
-	}
-}

vendor/github.com/emicklei/go-restful/compressor_pools.go

-package restful
-
-// Copyright 2015 Ernest Micklei. All rights reserved.
-// Use of this source code is governed by a license
-// that can be found in the LICENSE file.
-
-import (
-	"bytes"
-	"compress/gzip"
-	"compress/zlib"
-	"sync"
-)
-
-// SyncPoolCompessors is a CompressorProvider that use the standard sync.Pool.
-type SyncPoolCompessors struct {
-	GzipWriterPool *sync.Pool
-	GzipReaderPool *sync.Pool
-	ZlibWriterPool *sync.Pool
-}
-
-// NewSyncPoolCompessors returns a new ("empty") SyncPoolCompessors.
-func NewSyncPoolCompessors() *SyncPoolCompessors {
-	return &SyncPoolCompessors{
-		GzipWriterPool: &sync.Pool{
-			New: func() interface{} { return newGzipWriter() },
-		},
-		GzipReaderPool: &sync.Pool{
-			New: func() interface{} { return newGzipReader() },
-		},
-		ZlibWriterPool: &sync.Pool{
-			New: func() interface{} { return newZlibWriter() },
-		},
-	}
-}
-
-func (s *SyncPoolCompessors) AcquireGzipWriter() *gzip.Writer {
-	return s.GzipWriterPool.Get().(*gzip.Writer)
-}
-
-func (s *SyncPoolCompessors) ReleaseGzipWriter(w *gzip.Writer) {
-	s.GzipWriterPool.Put(w)
-}
-
-func (s *SyncPoolCompessors) AcquireGzipReader() *gzip.Reader {
-	return s.GzipReaderPool.Get().(*gzip.Reader)
-}
-
-func (s *SyncPoolCompessors) ReleaseGzipReader(r *gzip.Reader) {
-	s.GzipReaderPool.Put(r)
-}
-
-func (s *SyncPoolCompessors) AcquireZlibWriter() *zlib.Writer {
-	return s.ZlibWriterPool.Get().(*zlib.Writer)
-}
-
-func (s *SyncPoolCompessors) ReleaseZlibWriter(w *zlib.Writer) {
-	s.ZlibWriterPool.Put(w)
-}
-
-func newGzipWriter() *gzip.Writer {
-	// create with an empty bytes writer; it will be replaced before using the gzipWriter
-	writer, err := gzip.NewWriterLevel(new(bytes.Buffer), gzip.BestSpeed)
-	if err != nil {
-		panic(err.Error())
-	}
-	return writer
-}
-
-func newGzipReader() *gzip.Reader {
-	// create with an empty reader (but with GZIP header); it will be replaced before using the gzipReader
-	// we can safely use currentCompressProvider because it is set on package initialization.
-	w := currentCompressorProvider.AcquireGzipWriter()
-	defer currentCompressorProvider.ReleaseGzipWriter(w)
-	b := new(bytes.Buffer)
-	w.Reset(b)
-	w.Flush()
-	w.Close()
-	reader, err := gzip.NewReader(bytes.NewReader(b.Bytes()))
-	if err != nil {
-		panic(err.Error())
-	}
-	return reader
-}
-
-func newZlibWriter() *zlib.Writer {
-	writer, err := zlib.NewWriterLevel(new(bytes.Buffer), gzip.BestSpeed)
-	if err != nil {
-		panic(err.Error())
-	}
-	return writer
-}

vendor/github.com/emicklei/go-restful/compressors.go

-package restful
-
-// Copyright 2015 Ernest Micklei. All rights reserved.
-// Use of this source code is governed by a license
-// that can be found in the LICENSE file.
-
-import (
-	"compress/gzip"
-	"compress/zlib"
-)
-
-// CompressorProvider describes a component that can provider compressors for the std methods.
-type CompressorProvider interface {
-	// Returns a *gzip.Writer which needs to be released later.
-	// Before using it, call Reset().
-	AcquireGzipWriter() *gzip.Writer
-
-	// Releases an acquired *gzip.Writer.
-	ReleaseGzipWriter(w *gzip.Writer)
-
-	// Returns a *gzip.Reader which needs to be released later.
-	AcquireGzipReader() *gzip.Reader
-
-	// Releases an acquired *gzip.Reader.
-	ReleaseGzipReader(w *gzip.Reader)
-
-	// Returns a *zlib.Writer which needs to be released later.
-	// Before using it, call Reset().
-	AcquireZlibWriter() *zlib.Writer
-
-	// Releases an acquired *zlib.Writer.
-	ReleaseZlibWriter(w *zlib.Writer)
-}
-
-// DefaultCompressorProvider is the actual provider of compressors (zlib or gzip).
-var currentCompressorProvider CompressorProvider
-
-func init() {
-	currentCompressorProvider = NewSyncPoolCompessors()
-}
-
-// CurrentCompressorProvider returns the current CompressorProvider.
-// It is initialized using a SyncPoolCompessors.
-func CurrentCompressorProvider() CompressorProvider {
-	return currentCompressorProvider
-}
-
-// SetCompressorProvider sets the actual provider of compressors (zlib or gzip).
-func SetCompressorProvider(p CompressorProvider) {
-	if p == nil {
-		panic("cannot set compressor provider to nil")
-	}
-	currentCompressorProvider = p
-}

vendor/github.com/emicklei/go-restful/constants.go

-package restful
-
-// Copyright 2013 Ernest Micklei. All rights reserved.
-// Use of this source code is governed by a license
-// that can be found in the LICENSE file.
-
-const (
-	MIME_XML   = "application/xml"          // Accept or Content-Type used in Consumes() and/or Produces()
-	MIME_JSON  = "application/json"         // Accept or Content-Type used in Consumes() and/or Produces()
-	MIME_OCTET = "application/octet-stream" // If Content-Type is not present in request, use the default
-
-	HEADER_Allow                         = "Allow"
-	HEADER_Accept                        = "Accept"
-	HEADER_Origin                        = "Origin"
-	HEADER_ContentType                   = "Content-Type"
-	HEADER_LastModified                  = "Last-Modified"
-	HEADER_AcceptEncoding                = "Accept-Encoding"
-	HEADER_ContentEncoding               = "Content-Encoding"
-	HEADER_AccessControlExposeHeaders    = "Access-Control-Expose-Headers"
-	HEADER_AccessControlRequestMethod    = "Access-Control-Request-Method"
-	HEADER_AccessControlRequestHeaders   = "Access-Control-Request-Headers"
-	HEADER_AccessControlAllowMethods     = "Access-Control-Allow-Methods"
-	HEADER_AccessControlAllowOrigin      = "Access-Control-Allow-Origin"
-	HEADER_AccessControlAllowCredentials = "Access-Control-Allow-Credentials"
-	HEADER_AccessControlAllowHeaders     = "Access-Control-Allow-Headers"
-	HEADER_AccessControlMaxAge           = "Access-Control-Max-Age"
-
-	ENCODING_GZIP    = "gzip"
-	ENCODING_DEFLATE = "deflate"
-)

vendor/github.com/emicklei/go-restful/container_test.go

-package restful
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-// go test -v -test.run TestContainer_computeAllowedMethods ...restful
-func TestContainer_computeAllowedMethods(t *testing.T) {
-	wc := NewContainer()
-	ws1 := new(WebService).Path("/users")
-	ws1.Route(ws1.GET("{i}").To(dummy))
-	ws1.Route(ws1.POST("{i}").To(dummy))
-	wc.Add(ws1)
-	httpRequest, _ := http.NewRequest("GET", "http://api.his.com/users/1", nil)
-	rreq := Request{Request: httpRequest}
-	m := wc.computeAllowedMethods(&rreq)
-	if len(m) != 2 {
-		t.Errorf("got %d expected 2 methods, %v", len(m), m)
-	}
-}
-
-func TestContainer_HandleWithFilter(t *testing.T) {
-	prefilterCalled := false
-	postfilterCalled := false
-	httpHandlerCalled := false
-
-	wc := NewContainer()
-	wc.Filter(func(request *Request, response *Response, chain *FilterChain) {
-		prefilterCalled = true
-		chain.ProcessFilter(request, response)
-	})
-	wc.HandleWithFilter("/", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		httpHandlerCalled = true
-		w.Write([]byte("ok"))
-	}))
-	wc.Filter(func(request *Request, response *Response, chain *FilterChain) {
-		postfilterCalled = true
-		chain.ProcessFilter(request, response)
-	})
-
-	recorder := httptest.NewRecorder()
-	request, _ := http.NewRequest("GET", "/", nil)
-	wc.ServeHTTP(recorder, request)
-	if recorder.Code != http.StatusOK {
-		t.Errorf("unexpected code %d", recorder.Code)
-	}
-	if recorder.Body.String() != "ok" {
-		t.Errorf("unexpected body %s", recorder.Body.String())
-	}
-	if !prefilterCalled {
-		t.Errorf("filter added before calling HandleWithFilter wasn't called")
-	}
-	if !postfilterCalled {
-		t.Errorf("filter added after calling HandleWithFilter wasn't called")
-	}
-	if !httpHandlerCalled {
-		t.Errorf("handler added by calling HandleWithFilter wasn't called")
-	}
-}
-
-func TestContainerAddAndRemove(t *testing.T) {
-	ws1 := new(WebService).Path("/")
-	ws2 := new(WebService).Path("/users")
-	wc := NewContainer()
-	wc.Add(ws1)
-	wc.Add(ws2)
-	wc.Remove(ws2)
-	if len(wc.webServices) != 1 {
-		t.Errorf("expected one webservices")
-	}
-	if !wc.isRegisteredOnRoot {
-		t.Errorf("expected on root registered")
-	}
-	wc.Remove(ws1)
-	if len(wc.webServices) > 0 {
-		t.Errorf("expected zero webservices")
-	}
-	if wc.isRegisteredOnRoot {
-		t.Errorf("expected not on root registered")
-	}
-}

vendor/github.com/emicklei/go-restful/cors_filter.go

-package restful
-
-// Copyright 2013 Ernest Micklei. All rights reserved.
-// Use of this source code is governed by a license
-// that can be found in the LICENSE file.
-
-import (
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-// CrossOriginResourceSharing is used to create a Container Filter that implements CORS.
-// Cross-origin resource sharing (CORS) is a mechanism that allows JavaScript on a web page
-// to make XMLHttpRequests to another domain, not the domain the JavaScript originated from.
-//
-// http://en.wikipedia.org/wiki/Cross-origin_resource_sharing
-// http://enable-cors.org/server.html
-// http://www.html5rocks.com/en/tutorials/cors/#toc-handling-a-not-so-simple-request
-type CrossOriginResourceSharing struct {
-	ExposeHeaders  []string // list of Header names
-	AllowedHeaders []string // list of Header names
-	AllowedDomains []string // list of allowed values for Http Origin. An allowed value can be a regular expression to support subdomain matching. If empty all are allowed.
-	AllowedMethods []string
-	MaxAge         int // number of seconds before requiring new Options request
-	CookiesAllowed bool
-	Container      *Container
-
-	allowedOriginPatterns []*regexp.Regexp // internal field for origin regexp check.
-}
-
-// Filter is a filter function that implements the CORS flow as documented on http://enable-cors.org/server.html
-// and http://www.html5rocks.com/static/images/cors_server_flowchart.png
-func (c CrossOriginResourceSharing) Filter(req *Request, resp *Response, chain *FilterChain) {
-	origin := req.Request.Header.Get(HEADER_Origin)
-	if len(origin) == 0 {
-		if trace {
-			traceLogger.Print("no Http header Origin set")
-		}
-		chain.ProcessFilter(req, resp)
-		return
-	}
-	if !c.isOriginAllowed(origin) { // check whether this origin is allowed
-		if trace {
-			traceLogger.Printf("HTTP Origin:%s is not part of %v, neither matches any part of %v", origin, c.AllowedDomains, c.allowedOriginPatterns)
-		}
-		chain.ProcessFilter(req, resp)
-		return
-	}
-	if req.Request.Method != "OPTIONS" {
-		c.doActualRequest(req, resp)
-		chain.ProcessFilter(req, resp)
-		return
-	}
-	if acrm := req.Request.Header.Get(HEADER_AccessControlRequestMethod); acrm != "" {
-		c.doPreflightRequest(req, resp)
-	} else {
-		c.doActualRequest(req, resp)
-		chain.ProcessFilter(req, resp)
-		return
-	}
-}
-
-func (c CrossOriginResourceSharing) doActualRequest(req *Request, resp *Response) {
-	c.setOptionsHeaders(req, resp)
-	// continue processing the response
-}
-
-func (c *CrossOriginResourceSharing) doPreflightRequest(req *Request, resp *Response) {
-	if len(c.AllowedMethods) == 0 {
-		if c.Container == nil {
-			c.AllowedMethods = DefaultContainer.computeAllowedMethods(req)
-		} else {
-			c.AllowedMethods = c.Container.computeAllowedMethods(req)
-		}
-	}
-
-	acrm := req.Request.Header.Get(HEADER_AccessControlRequestMethod)
-	if !c.isValidAccessControlRequestMethod(acrm, c.AllowedMethods) {
-		if trace {
-			traceLogger.Printf("Http header %s:%s is not in %v",
-				HEADER_AccessControlRequestMethod,
-				acrm,
-				c.AllowedMethods)
-		}
-		return
-	}
-	acrhs := req.Request.Header.Get(HEADER_AccessControlRequestHeaders)
-	if len(acrhs) > 0 {
-		for _, each := range strings.Split(acrhs, ",") {
-			if !c.isValidAccessControlRequestHeader(strings.Trim(each, " ")) {
-				if trace {
-					traceLogger.Printf("Http header %s:%s is not in %v",
-						HEADER_AccessControlRequestHeaders,
-						acrhs,
-						c.AllowedHeaders)
-				}
-				return
-			}
-		}
-	}
-	resp.AddHeader(HEADER_AccessControlAllowMethods, strings.Join(c.AllowedMethods, ","))
-	resp.AddHeader(HEADER_AccessControlAllowHeaders, acrhs)
-	c.setOptionsHeaders(req, resp)
-
-	// return http 200 response, no body
-}
-
-func (c CrossOriginResourceSharing) setOptionsHeaders(req *Request, resp *Response) {
-	c.checkAndSetExposeHeaders(resp)
-	c.setAllowOriginHeader(req, resp)
-	c.checkAndSetAllowCredentials(resp)
-	if c.MaxAge > 0 {
-		resp.AddHeader(HEADER_AccessControlMaxAge, strconv.Itoa(c.MaxAge))
-	}
-}
-
-func (c CrossOriginResourceSharing) isOriginAllowed(origin string) bool {
-	if len(origin) == 0 {
-		return false
-	}
-	if len(c.AllowedDomains) == 0 {
-		return true
-	}
-
-	allowed := false
-	for _, domain := range c.AllowedDomains {
-		if domain == origin {
-			allowed = true
-			break
-		}
-	}
-
-	if !allowed {
-		if len(c.allowedOriginPatterns) == 0 {
-			// compile allowed domains to allowed origin patterns
-			allowedOriginRegexps, err := compileRegexps(c.AllowedDomains)
-			if err != nil {
-				return false
-			}
-			c.allowedOriginPatterns = allowedOriginRegexps
-		}
-
-		for _, pattern := range c.allowedOriginPatterns {
-			if allowed = pattern.MatchString(origin); allowed {
-				break
-			}
-		}
-	}
-
-	return allowed
-}
-
-func (c CrossOriginResourceSharing) setAllowOriginHeader(req *Request, resp *Response) {
-	origin := req.Request.Header.Get(HEADER_Origin)
-	if c.isOriginAllowed(origin) {
-		resp.AddHeader(HEADER_AccessControlAllowOrigin, origin)
-	}
-}
-
-func (c CrossOriginResourceSharing) checkAndSetExposeHeaders(resp *Response) {
-	if len(c.ExposeHeaders) > 0 {
-		resp.AddHeader(HEADER_AccessControlExposeHeaders, strings.Join(c.ExposeHeaders, ","))
-	}
-}
-
-func (c CrossOriginResourceSharing) checkAndSetAllowCredentials(resp *Response) {
-	if c.CookiesAllowed {
-		resp.AddHeader(HEADER_AccessControlAllowCredentials, "true")
-	}
-}
-
-func (c CrossOriginResourceSharing) isValidAccessControlRequestMethod(method string, allowedMethods []string) bool {
-	for _, each := range allowedMethods {
-		if each == method {
-			return true
-		}
-	}
-	return false
-}
-
-func (c CrossOriginResourceSharing) isValidAccessControlRequestHeader(header string) bool {
-	for _, each := range c.AllowedHeaders {
-		if strings.ToLower(each) == strings.ToLower(header) {
-			return true
-		}
-	}
-	return false
-}
-
-// Take a list of strings and compile them into a list of regular expressions.
-func compileRegexps(regexpStrings []string) ([]*regexp.Regexp, error) {
-	regexps := []*regexp.Regexp{}
-	for _, regexpStr := range regexpStrings {
-		r, err := regexp.Compile(regexpStr)
-		if err != nil {
-			return regexps, err
-		}
-		regexps = append(regexps, r)
-	}
-	return regexps, nil
-}

vendor/github.com/emicklei/go-restful/cors_filter_test.go

-package restful
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-// go test -v -test.run TestCORSFilter_Preflight ...restful
-// http://www.html5rocks.com/en/tutorials/cors/#toc-handling-a-not-so-simple-request
-func TestCORSFilter_Preflight(t *testing.T) {
-	tearDown()
-	ws := new(WebService)
-	ws.Route(ws.PUT("/cors").To(dummy))
-	Add(ws)
-
-	cors := CrossOriginResourceSharing{
-		ExposeHeaders:  []string{"X-Custom-Header"},
-		AllowedHeaders: []string{"X-Custom-Header", "X-Additional-Header"},
-		CookiesAllowed: true,
-		Container:      DefaultContainer}
-	Filter(cors.Filter)
-
-	// Preflight
-	httpRequest, _ := http.NewRequest("OPTIONS", "http://api.alice.com/cors", nil)
-	httpRequest.Method = "OPTIONS"
-	httpRequest.Header.Set(HEADER_Origin, "http://api.bob.com")
-	httpRequest.Header.Set(HEADER_AccessControlRequestMethod, "PUT")
-	httpRequest.Header.Set(HEADER_AccessControlRequestHeaders, "X-Custom-Header, X-Additional-Header")
-
-	httpWriter := httptest.NewRecorder()
-	DefaultContainer.Dispatch(httpWriter, httpRequest)
-
-	actual := httpWriter.Header().Get(HEADER_AccessControlAllowOrigin)
-	if "http://api.bob.com" != actual {
-		t.Fatal("expected: http://api.bob.com but got:" + actual)
-	}
-	actual = httpWriter.Header().Get(HEADER_AccessControlAllowMethods)
-	if "PUT" != actual {
-		t.Fatal("expected: PUT but got:" + actual)
-	}
-	actual = httpWriter.Header().Get(HEADER_AccessControlAllowHeaders)
-	if "X-Custom-Header, X-Additional-Header" != actual {
-		t.Fatal("expected: X-Custom-Header, X-Additional-Header but got:" + actual)
-	}
-
-	if !cors.isOriginAllowed("somewhere") {
-		t.Fatal("origin expected to be allowed")
-	}
-	cors.AllowedDomains = []string{"overthere.com"}
-	if cors.isOriginAllowed("somewhere") {
-		t.Fatal("origin [somewhere] expected NOT to be allowed")
-	}
-	if !cors.isOriginAllowed("overthere.com") {
-		t.Fatal("origin [overthere] expected to be allowed")
-	}
-
-}
-
-// go test -v -test.run TestCORSFilter_Actual ...restful
-// http://www.html5rocks.com/en/tutorials/cors/#toc-handling-a-not-so-simple-request
-func TestCORSFilter_Actual(t *testing.T) {
-	tearDown()
-	ws := new(WebService)
-	ws.Route(ws.PUT("/cors").To(dummy))
-	Add(ws)
-
-	cors := CrossOriginResourceSharing{
-		ExposeHeaders:  []string{"X-Custom-Header"},
-		AllowedHeaders: []string{"X-Custom-Header", "X-Additional-Header"},
-		CookiesAllowed: true,
-		Container:      DefaultContainer}
-	Filter(cors.Filter)
-
-	// Actual
-	httpRequest, _ := http.NewRequest("PUT", "http://api.alice.com/cors", nil)
-	httpRequest.Header.Set(HEADER_Origin, "http://api.bob.com")
-	httpRequest.Header.Set("X-Custom-Header", "value")
-
-	httpWriter := httptest.NewRecorder()
-	DefaultContainer.Dispatch(httpWriter, httpRequest)
-	actual := httpWriter.Header().Get(HEADER_AccessControlAllowOrigin)
-	if "http://api.bob.com" != actual {
-		t.Fatal("expected: http://api.bob.com but got:" + actual)
-	}
-	if httpWriter.Body.String() != "dummy" {
-		t.Fatal("expected: dummy but got:" + httpWriter.Body.String())
-	}
-}
-
-var allowedDomainInput = []struct {
-	domains []string
-	origin  string
-	allowed bool
-}{
-	{[]string{}, "http://anything.com", true},
-	{[]string{"example.com"}, "example.com", true},
-	{[]string{"example.com"}, "not-allowed", false},
-	{[]string{"not-matching.com", "example.com"}, "example.com", true},
-	{[]string{".*"}, "example.com", true},
-}
-
-// go test -v -test.run TestCORSFilter_AllowedDomains ...restful
-func TestCORSFilter_AllowedDomains(t *testing.T) {
-	for _, each := range allowedDomainInput {
-		tearDown()
-		ws := new(WebService)
-		ws.Route(ws.PUT("/cors").To(dummy))
-		Add(ws)
-
-		cors := CrossOriginResourceSharing{
-			AllowedDomains: each.domains,
-			CookiesAllowed: true,
-			Container:      DefaultContainer}
-		Filter(cors.Filter)
-
-		httpRequest, _ := http.NewRequest("PUT", "http://api.his.com/cors", nil)
-		httpRequest.Header.Set(HEADER_Origin, each.origin)
-		httpWriter := httptest.NewRecorder()
-		DefaultContainer.Dispatch(httpWriter, httpRequest)
-		actual := httpWriter.Header().Get(HEADER_AccessControlAllowOrigin)
-		if actual != each.origin && each.allowed {
-			t.Fatal("expected to be accepted")
-		}
-		if actual == each.origin && !each.allowed {
-			t.Fatal("did not expect to be accepted")
-		}
-	}
-}

vendor/github.com/emicklei/go-restful/coverage.sh

-go test -coverprofile=coverage.out
-go tool cover -html=coverage.out
\ No newline at end of file

vendor/github.com/emicklei/go-restful/curly.go

-package restful
-
-// Copyright 2013 Ernest Micklei. All rights reserved.
-// Use of this source code is governed by a license
-// that can be found in the LICENSE file.
-
-import (
-	"net/http"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-// CurlyRouter expects Routes with paths that contain zero or more parameters in curly brackets.
-type CurlyRouter struct{}
-
-// SelectRoute is part of the Router interface and returns the best match
-// for the WebService and its Route for the given Request.
-func (c CurlyRouter) SelectRoute(
-	webServices []*WebService,
-	httpRequest *http.Request) (selectedService *WebService, selected *Route, err error) {
-
-	requestTokens := tokenizePath(httpRequest.URL.Path)
-
-	detectedService := c.detectWebService(requestTokens, webServices)
-	if detectedService == nil {
-		if trace {
-			traceLogger.Printf("no WebService was found to match URL path:%s\n", httpRequest.URL.Path)
-		}
-		return nil, nil, NewError(http.StatusNotFound, "404: Page Not Found")
-	}
-	candidateRoutes := c.selectRoutes(detectedService, requestTokens)
-	if len(candidateRoutes) == 0 {
-		if trace {
-			traceLogger.Printf("no Route in WebService with path %s was found to match URL path:%s\n", detectedService.rootPath, httpRequest.URL.Path)
-		}
-		return detectedService, nil, NewError(http.StatusNotFound, "404: Page Not Found")
-	}
-	selectedRoute, err := c.detectRoute(candidateRoutes, httpRequest)
-	if selectedRoute == nil {
-		return detectedService, nil, err
-	}
-	return detectedService, selectedRoute, nil
-}
-
-// selectRoutes return a collection of Route from a WebService that matches the path tokens from the request.
-func (c CurlyRouter) selectRoutes(ws *WebService, requestTokens []string) sortableCurlyRoutes {
-	candidates := sortableCurlyRoutes{}
-	for _, each := range ws.routes {
-		matches, paramCount, staticCount := c.matchesRouteByPathTokens(each.pathParts, requestTokens)
-		if matches {
-			candidates.add(curlyRoute{each, paramCount, staticCount}) // TODO make sure Routes() return pointers?
-		}
-	}
-	sort.Sort(sort.Reverse(candidates))
-	return candidates
-}
-
-// matchesRouteByPathTokens computes whether it matches, howmany parameters do match and what the number of static path elements are.
-func (c CurlyRouter) matchesRouteByPathTokens(routeTokens, requestTokens []string) (matches bool, paramCount int, staticCount int) {
-	if len(routeTokens) < len(requestTokens) {
-		// proceed in matching only if last routeToken is wildcard
-		count := len(routeTokens)
-		if count == 0 || !strings.HasSuffix(routeTokens[count-1], "*}") {
-			return false, 0, 0
-		}
-		// proceed
-	}
-	for i, routeToken := range routeTokens {
-		if i == len(requestTokens) {
-			// reached end of request path
-			return false, 0, 0
-		}
-		requestToken := requestTokens[i]
-		if strings.HasPrefix(routeToken, "{") {
-			paramCount++
-			if colon := strings.Index(routeToken, ":"); colon != -1 {
-				// match by regex
-				matchesToken, matchesRemainder := c.regularMatchesPathToken(routeToken, colon, requestToken)
-				if !matchesToken {
-					return false, 0, 0
-				}
-				if matchesRemainder {
-					break
-				}
-			}
-		} else { // no { prefix
-			if requestToken != routeToken {
-				return false, 0, 0
-			}
-			staticCount++
-		}
-	}
-	return true, paramCount, staticCount
-}
-
-// regularMatchesPathToken tests whether the regular expression part of routeToken matches the requestToken or all remaining tokens
-// format routeToken is {someVar:someExpression}, e.g. {zipcode:[\d][\d][\d][\d][A-Z][A-Z]}
-func (c CurlyRouter) regularMatchesPathToken(routeToken string, colon int, requestToken string) (matchesToken bool, matchesRemainder bool) {
-	regPart := routeToken[colon+1 : len(routeToken)-1]
-	if regPart == "*" {
-		if trace {
-			traceLogger.Printf("wildcard parameter detected in route token %s that matches %s\n", routeToken, requestToken)
-		}
-		return true, true
-	}
-	matched, err := regexp.MatchString(regPart, requestToken)
-	return (matched && err == nil), false
-}
-
-var jsr311Router = RouterJSR311{}
-
-// detectRoute selectes from a list of Route the first match by inspecting both the Accept and Content-Type
-// headers of the Request. See also RouterJSR311 in jsr311.go
-func (c CurlyRouter) detectRoute(candidateRoutes sortableCurlyRoutes, httpRequest *http.Request) (*Route, error) {
-	// tracing is done inside detectRoute
-	return jsr311Router.detectRoute(candidateRoutes.routes(), httpRequest)
-}
-
-// detectWebService returns the best matching webService given the list of path tokens.
-// see also computeWebserviceScore
-func (c CurlyRouter) detectWebService(requestTokens []string, webServices []*WebService) *WebService {
-	var best *WebService
-	score := -1
-	for _, each := range webServices {
-		matches, eachScore := c.computeWebserviceScore(requestTokens, each.pathExpr.tokens)
-		if matches && (eachScore > score) {
-			best = each
-			score = eachScore
-		}
-	}
-	return best
-}
-
-// computeWebserviceScore returns whether tokens match and
-// the weighted score of the longest matching consecutive tokens from the beginning.
-func (c CurlyRouter) computeWebserviceScore(requestTokens []string, tokens []string) (bool, int) {
-	if len(tokens) > len(requestTokens) {
-		return false, 0
-	}
-	score := 0
-	for i := 0; i < len(tokens); i++ {
-		each := requestTokens[i]
-		other := tokens[i]
-		if len(each) == 0 && len(other) == 0 {
-			score++
-			continue
-		}
-		if len(other) > 0 && strings.HasPrefix(other, "{") {
-			// no empty match
-			if len(each) == 0 {
-				return false, score
-			}
-			score += 1
-		} else {
-			// not a parameter
-			if each != other {
-				return false, score
-			}
-			score += (len(tokens) - i) * 10 //fuzzy
-		}
-	}
-	return true, score
-}

vendor/github.com/emicklei/go-restful/curly_route.go

-package restful
-
-// Copyright 2013 Ernest Micklei. All rights reserved.
-// Use of this source code is governed by a license
-// that can be found in the LICENSE file.
-
-// curlyRoute exits for sorting Routes by the CurlyRouter based on number of parameters and number of static path elements.
-type curlyRoute struct {
-	route       Route
-	paramCount  int
-	staticCount int
-}
-
-type sortableCurlyRoutes []curlyRoute
-
-func (s *sortableCurlyRoutes) add(route curlyRoute) {
-	*s = append(*s, route)
-}
-
-func (s sortableCurlyRoutes) routes() (routes []Route) {
-	for _, each := range s {
-		routes = append(routes, each.route) // TODO change return type
-	}
-	return routes
-}
-
-func (s sortableCurlyRoutes) Len() int {
-	return len(s)
-}
-func (s sortableCurlyRoutes) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
-}
-func (s sortableCurlyRoutes) Less(i, j int) bool {
-	ci := s[i]
-	cj := s[j]
-
-	// primary key
-	if ci.staticCount < cj.staticCount {
-		return true
-	}
-	if ci.staticCount > cj.staticCount {
-		return false
-	}
-	// secundary key
-	if ci.paramCount < cj.paramCount {
-		return true
-	}
-	if ci.paramCount > cj.paramCount {
-		return false
-	}
-	return ci.route.Path < cj.route.Path
-}

vendor/github.com/emicklei/go-restful/curly_test.go

-package restful
-
-import (
-	"io"
-	"net/http"
-	"testing"
-)
-
-var requestPaths = []struct {
-	// url with path (1) is handled by service with root (2) and remainder has value final (3)
-	path, root string
-}{
-	{"/", "/"},
-	{"/p", "/p"},
-	{"/p/x", "/p/{q}"},
-	{"/q/x", "/q"},
-	{"/p/x/", "/p/{q}"},
-	{"/p/x/y", "/p/{q}"},
-	{"/q/x/y", "/q"},
-	{"/z/q", "/{p}/q"},
-	{"/a/b/c/q", "/"},
-}
-
-// go test -v -test.run TestCurlyDetectWebService ...restful
-func TestCurlyDetectWebService(t *testing.T) {
-	ws1 := new(WebService).Path("/")
-	ws2 := new(WebService).Path("/p")
-	ws3 := new(WebService).Path("/q")
-	ws4 := new(WebService).Path("/p/q")
-	ws5 := new(WebService).Path("/p/{q}")
-	ws7 := new(WebService).Path("/{p}/q")
-	var wss = []*WebService{ws1, ws2, ws3, ws4, ws5, ws7}
-
-	for _, each := range wss {
-		t.Logf("path=%s,toks=%v\n", each.pathExpr.Source, each.pathExpr.tokens)
-	}
-
-	router := CurlyRouter{}
-
-	ok := true
-	for i, fixture := range requestPaths {
-		requestTokens := tokenizePath(fixture.path)
-		who := router.detectWebService(requestTokens, wss)
-		if who != nil && who.RootPath() != fixture.root {
-			t.Logf("[line:%v] Unexpected dispatcher, expected:%v, actual:%v", i, fixture.root, who.RootPath())
-			ok = false
-		}
-	}
-	if !ok {
-		t.Fail()
-	}
-}
-
-var serviceDetects = []struct {
-	path  string
-	found bool
-	root  string
-}{
-	{"/a/b", true, "/{p}/{q}/{r}"},
-	{"/p/q", true, "/p/q"},
-	{"/q/p", true, "/q"},
-	{"/", true, "/"},
-	{"/p/q/r", true, "/p/q"},
-}
-
-// go test -v -test.run Test_detectWebService ...restful
-func Test_detectWebService(t *testing.T) {
-	router := CurlyRouter{}
-	ws1 := new(WebService).Path("/")
-	ws2 := new(WebService).Path("/p")
-	ws3 := new(WebService).Path("/q")
-	ws4 := new(WebService).Path("/p/q")
-	ws5 := new(WebService).Path("/p/{q}")
-	ws6 := new(WebService).Path("/p/{q}/")
-	ws7 := new(WebService).Path("/{p}/q")
-	ws8 := new(WebService).Path("/{p}/{q}/{r}")
-	var wss = []*WebService{ws8, ws7, ws6, ws5, ws4, ws3, ws2, ws1}
-	for _, fix := range serviceDetects {
-		requestPath := fix.path
-		requestTokens := tokenizePath(requestPath)
-		for _, ws := range wss {
-			serviceTokens := ws.pathExpr.tokens
-			matches, score := router.computeWebserviceScore(requestTokens, serviceTokens)
-			t.Logf("req=%s,toks:%v,ws=%s,toks:%v,score=%d,matches=%v", requestPath, requestTokens, ws.RootPath(), serviceTokens, score, matches)
-		}
-		best := router.detectWebService(requestTokens, wss)
-		if best != nil {
-			if fix.found {
-				t.Logf("best=%s", best.RootPath())
-			} else {
-				t.Fatalf("should have found:%s", fix.root)
-			}
-		}
-	}
-}
-
-var routeMatchers = []struct {
-	route       string
-	path        string
-	matches     bool
-	paramCount  int
-	staticCount int
-}{
-	// route, request-path
-	{"/a", "/a", true, 0, 1},
-	{"/a", "/b", false, 0, 0},
-	{"/a", "/b", false, 0, 0},
-	{"/a/{b}/c/", "/a/2/c", true, 1, 2},
-	{"/{a}/{b}/{c}/", "/a/b", false, 0, 0},
-	{"/{x:*}", "/", false, 0, 0},
-	{"/{x:*}", "/a", true, 1, 0},
-	{"/{x:*}", "/a/b", true, 1, 0},
-	{"/a/{x:*}", "/a/b", true, 1, 1},
-	{"/a/{x:[A-Z][A-Z]}", "/a/ZX", true, 1, 1},
-	{"/basepath/{resource:*}", "/basepath/some/other/location/test.xml", true, 1, 1},
-}
-
-// clear && go test -v -test.run Test_matchesRouteByPathTokens ...restful
-func Test_matchesRouteByPathTokens(t *testing.T) {
-	router := CurlyRouter{}
-	for i, each := range routeMatchers {
-		routeToks := tokenizePath(each.route)
-		reqToks := tokenizePath(each.path)
-		matches, pCount, sCount := router.matchesRouteByPathTokens(routeToks, reqToks)
-		if matches != each.matches {
-			t.Fatalf("[%d] unexpected matches outcome route:%s, path:%s, matches:%v", i, each.route, each.path, matches)
-		}
-		if pCount != each.paramCount {
-			t.Fatalf("[%d] unexpected paramCount got:%d want:%d ", i, pCount, each.paramCount)
-		}
-		if sCount != each.staticCount {
-			t.Fatalf("[%d] unexpected staticCount got:%d want:%d ", i, sCount, each.staticCount)
-		}
-	}
-}
-
-// clear && go test -v -test.run TestExtractParameters_Wildcard1 ...restful
-func TestExtractParameters_Wildcard1(t *testing.T) {
-	params := doExtractParams("/fixed/{var:*}", 2, "/fixed/remainder", t)
-	if params["var"] != "remainder" {
-		t.Errorf("parameter mismatch var: %s", params["var"])
-	}
-}
-
-// clear && go test -v -test.run TestExtractParameters_Wildcard2 ...restful
-func TestExtractParameters_Wildcard2(t *testing.T) {
-	params := doExtractParams("/fixed/{var:*}", 2, "/fixed/remain/der", t)
-	if params["var"] != "remain/der" {
-		t.Errorf("parameter mismatch var: %s", params["var"])
-	}
-}
-
-// clear && go test -v -test.run TestExtractParameters_Wildcard3 ...restful
-func TestExtractParameters_Wildcard3(t *testing.T) {
-	params := doExtractParams("/static/{var:*}", 2, "/static/test/sub/hi.html", t)
-	if params["var"] != "test/sub/hi.html" {
-		t.Errorf("parameter mismatch var: %s", params["var"])
-	}
-}
-
-func TestExtractParameters_Wildcard4(t *testing.T) {
-	params := doExtractParams("/static/{var:*}/sub", 3, "/static/test/sub", t)
-	if params["var"] != "test/sub" {
-		t.Errorf("parameter mismatch var: %s", params["var"])
-	}
-}
-
-// clear && go test -v -test.run TestCurly_ISSUE_34 ...restful
-func TestCurly_ISSUE_34(t *testing.T) {
-	ws1 := new(WebService).Path("/")
-	ws1.Route(ws1.GET("/{type}/{id}").To(curlyDummy))
-	ws1.Route(ws1.GET("/network/{id}").To(curlyDummy))
-	croutes := CurlyRouter{}.selectRoutes(ws1, tokenizePath("/network/12"))
-	if len(croutes) != 2 {
-		t.Fatal("expected 2 routes")
-	}
-	if got, want := croutes[0].route.Path, "/network/{id}"; got != want {
-		t.Errorf("got %v want %v", got, want)
-	}
-}
-
-// clear && go test -v -test.run TestCurly_ISSUE_34_2 ...restful
-func TestCurly_ISSUE_34_2(t *testing.T) {
-	ws1 := new(WebService)
-	ws1.Route(ws1.GET("/network/{id}").To(curlyDummy))
-	ws1.Route(ws1.GET("/{type}/{id}").To(curlyDummy))
-	croutes := CurlyRouter{}.selectRoutes(ws1, tokenizePath("/network/12"))
-	if len(croutes) != 2 {
-		t.Fatal("expected 2 routes")
-	}
-	if got, want := croutes[0].route.Path, "/network/{id}"; got != want {
-		t.Errorf("got %v want %v", got, want)
-	}
-}
-
-// clear && go test -v -test.run TestCurly_JsonHtml ...restful
-func TestCurly_JsonHtml(t *testing.T) {
-	ws1 := new(WebService)
-	ws1.Path("/")
-	ws1.Route(ws1.GET("/some.html").To(curlyDummy).Consumes("*/*").Produces("text/html"))
-	req, _ := http.NewRequest("GET", "/some.html", nil)
-	req.Header.Set("Accept", "application/json")
-	_, route, err := CurlyRouter{}.SelectRoute([]*WebService{ws1}, req)
-	if err == nil {
-		t.Error("error expected")
-	}
-	if route != nil {
-		t.Error("no route expected")
-	}
-}
-
-// go test -v -test.run TestCurly_ISSUE_137 ...restful
-func TestCurly_ISSUE_137(t *testing.T) {
-	ws1 := new(WebService)
-	ws1.Route(ws1.GET("/hello").To(curlyDummy))
-	ws1.Path("/")
-	req, _ := http.NewRequest("GET", "/", nil)
-	_, route, _ := CurlyRouter{}.SelectRoute([]*WebService{ws1}, req)
-	t.Log(route)
-	if route != nil {
-		t.Error("no route expected")
-	}
-}
-
-// go test -v -test.run TestCurly_ISSUE_137_2 ...restful
-func TestCurly_ISSUE_137_2(t *testing.T) {
-	ws1 := new(WebService)
-	ws1.Route(ws1.GET("/hello").To(curlyDummy))
-	ws1.Path("/")
-	req, _ := http.NewRequest("GET", "/hello/bob", nil)
-	_, route, _ := CurlyRouter{}.SelectRoute([]*WebService{ws1}, req)
-	t.Log(route)
-	if route != nil {
-		t.Errorf("no route expected, got %v", route)
-	}
-}
-
-func curlyDummy(req *Request, resp *Response) { io.WriteString(resp.ResponseWriter, "curlyDummy") }

vendor/github.com/emicklei/go-restful/doc_examples_test.go

-package restful
-
-import "net/http"
-
-func ExampleOPTIONSFilter() {
-	// Install the OPTIONS filter on the default Container
-	Filter(OPTIONSFilter())
-}
-func ExampleContainer_OPTIONSFilter() {
-	// Install the OPTIONS filter on a Container
-	myContainer := new(Container)
-	myContainer.Filter(myContainer.OPTIONSFilter)
-}
-
-func ExampleContainer() {
-	// The Default container of go-restful uses the http.DefaultServeMux.
-	// You can create your own Container using restful.NewContainer() and create a new http.Server for that particular container
-
-	ws := new(WebService)
-	wsContainer := NewContainer()
-	wsContainer.Add(ws)
-	server := &http.Server{Addr: ":8080", Handler: wsContainer}
-	server.ListenAndServe()
-}
-
-func ExampleCrossOriginResourceSharing() {
-	// To install this filter on the Default Container use:
-	cors := CrossOriginResourceSharing{ExposeHeaders: []string{"X-My-Header"}, CookiesAllowed: false, Container: DefaultContainer}
-	Filter(cors.Filter)
-}
-
-func ExampleServiceError() {
-	resp := new(Response)
-	resp.WriteEntity(NewError(http.StatusBadRequest, "Non-integer {id} path parameter"))
-}
-
-func ExampleBoundedCachedCompressors() {
-	// Register a compressor provider (gzip/deflate read/write) that uses
-	// a bounded cache with a maximum of 20 writers and 20 readers.
-	SetCompressorProvider(NewBoundedCachedCompressors(20, 20))
-}

vendor/github.com/emicklei/go-restful/entity_accessors_test.go

-package restful
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"reflect"
-	"testing"
-)
-
-type keyvalue struct {
-	readCalled  bool
-	writeCalled bool
-}
-
-func (kv *keyvalue) Read(req *Request, v interface{}) error {
-	//t := reflect.TypeOf(v)
-	//rv := reflect.ValueOf(v)
-	kv.readCalled = true
-	return nil
-}
-
-func (kv *keyvalue) Write(resp *Response, status int, v interface{}) error {
-	t := reflect.TypeOf(v)
-	rv := reflect.ValueOf(v)
-	for ix := 0; ix < t.NumField(); ix++ {
-		sf := t.Field(ix)
-		io.WriteString(resp, sf.Name)
-		io.WriteString(resp, "=")
-		io.WriteString(resp, fmt.Sprintf("%v\n", rv.Field(ix).Interface()))
-	}
-	kv.writeCalled = true
-	return nil
-}
-
-// go test -v -test.run TestKeyValueEncoding ...restful
-func TestKeyValueEncoding(t *testing.T) {
-	type Book struct {
-		Title         string
-		Author        string
-		PublishedYear int
-	}
-	kv := new(keyvalue)
-	RegisterEntityAccessor("application/kv", kv)
-	b := Book{"Singing for Dummies", "john doe", 2015}
-
-	// Write
-	httpWriter := httptest.NewRecorder()
-	//								Accept									Produces
-	resp := Response{ResponseWriter: httpWriter, requestAccept: "application/kv,*/*;q=0.8", routeProduces: []string{"application/kv"}, prettyPrint: true}
-	resp.WriteEntity(b)
-	t.Log(string(httpWriter.Body.Bytes()))
-	if !kv.writeCalled {
-		t.Error("Write never called")
-	}
-
-	// Read
-	bodyReader := bytes.NewReader(httpWriter.Body.Bytes())
-	httpRequest, _ := http.NewRequest("GET", "/test", bodyReader)
-	httpRequest.Header.Set("Content-Type", "application/kv; charset=UTF-8")
-	request := NewRequest(httpRequest)
-	var bb Book
-	request.ReadEntity(&bb)
-	if !kv.readCalled {
-		t.Error("Read never called")
-	}
-}

vendor/github.com/go-openapi/jsonpointer/.gitignore

-secrets.yml

vendor/github.com/go-openapi/jsonreference/.gitignore

-secrets.yml