Merge pull request #1178 from errm/k8s-client-2

Upgrade k8s.io/client-go to version 2

glide.lock

@@ -1,12 +1,13 @@
-hash: 8349c21c53c639aa79752c4e4b07e323ddb4f05be783564d7de687afbb6f2d67
+hash: b1cbcbd938a47a246b0d4d634037b76e63486c63e5867b339f92bcbd7453b75c
-updated: 2017-03-28T22:35:17.448681338+02:00
+updated: 2017-04-07T11:34:46.101385591+01:00
 imports:
 - name: bitbucket.org/ww/goautoneg
   version: 75cd24fc2f2c2a2088577d12123ddee5f54e0675
 - name: cloud.google.com/go
-  version: c116c7972ec94f148459a304d07a67ecbc770d4b
+  version: 2e6a95edb1071d750f6d7db777bf66cd2997af6c
   subpackages:
   - compute/metadata
+  - internal
 - name: github.com/abbot/go-http-auth
   version: cb4372376e1e00e9f6ab9ec142e029302c9e7140
 - name: github.com/ArthurHlt/go-eureka-client
@@ -53,23 +54,22 @@ imports:
   - service/route53
   - service/sts
 - name: github.com/Azure/azure-sdk-for-go
-  version: 1620af6b32398bfc91827ceae54a8cc1f55df04d
+  version: 088007b3b08cc02b27f2eadfdcd870958460ce7e
   subpackages:
   - arm/dns
 - name: github.com/Azure/go-autorest
-  version: 32cc2321122a649b7ba4e323527bcb145134fd47
+  version: a2fdd780c9a50455cecd249b00bdc3eb73a78e31
   subpackages:
   - autorest
   - autorest/azure
   - autorest/date
   - autorest/to
-  - autorest/validation
 - name: github.com/beorn7/perks
   version: b965b613227fddccbfffe13eae360ed3fa822f8d
   subpackages:
   - quantile
 - name: github.com/blang/semver
-  version: 3a37c301dda64cbe17f16f661b4c976803c0e2d2
+  version: 31b736133b98f26d5e078ec9eb591666edfd091f
 - name: github.com/boltdb/bolt
   version: 5cc10bbbc5c141029940133bb33c9e969512a698
 - name: github.com/BurntSushi/toml
@@ -101,7 +101,7 @@ imports:
   - pkg/pathutil
   - pkg/types
 - name: github.com/coreos/go-oidc
-  version: 9e117111587506b9dc83b7b38263268bf48352ea
+  version: 5644a2f50e2d2d5ba0b474bc5bc55fea1925936d
   subpackages:
   - http
   - jose
@@ -113,9 +113,8 @@ imports:
   subpackages:
   - daemon
 - name: github.com/coreos/pkg
-  version: 2c77715c4df99b5420ffcae14ead08f52104065d
+  version: fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8
   subpackages:
-  - capnslog
   - health
   - httputil
   - timeutil
@@ -129,6 +128,10 @@ imports:
   version: f6b1d56f1c048bd94d7e42ac36efb4d57b069b6f
 - name: github.com/dgrijalva/jwt-go
   version: 9ed569b5d1ac936e6494082958d63a6aa4fff99a
+- name: github.com/dnsimple/dnsimple-go
+  version: 5a5b427618a76f9eed5ede0f3e6306fbd9311d2e
+  subpackages:
+  - dnsimple
 - name: github.com/docker/distribution
   version: 325b0804fef3a66309d962357aac3c2ce3f4d329
   subpackages:
@@ -198,7 +201,7 @@ imports:
 - name: github.com/gambol99/go-marathon
   version: 6b00a5b651b1beb2c6821863f7c60df490bd46c8
 - name: github.com/ghodss/yaml
-  version: 04f313413ffd65ce25f2541bfd2b2ceec5c0908c
+  version: 73d445a93680fa1a78ae23a5839bad48f32ba1ee
 - name: github.com/go-ini/ini
   version: 6f66b0e091edb3c7b380f7c4f0f884274d550b67
 - name: github.com/go-kit/kit
@@ -208,13 +211,13 @@ imports:
   - metrics/internal/lv
   - metrics/prometheus
 - name: github.com/go-openapi/jsonpointer
-  version: 8d96a2dc61536b690bd36b2e9df0b3c0b62825b2
+  version: 46af16f9f7b149af66e5d1bd010e3574dc06de98
 - name: github.com/go-openapi/jsonreference
-  version: 36d33bfe519efae5632669801b180bf1a245da3b
+  version: 13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272
 - name: github.com/go-openapi/spec
-  version: 34b5ffff717ab4535aef76e3dd90818bddde571b
+  version: 6aced65f8501fe1217321abf0749d354824ba2ff
 - name: github.com/go-openapi/swag
-  version: 96d7b9ebd181a1735a1c9ac87914f2b32fbf56c9
+  version: 1d0bd113de87027671077d3c71eb3ac5d7dbba72
 - name: github.com/gogo/protobuf
   version: 909568be09de550ed094403c2bf8a261b5bb730a
   subpackages:
@@ -235,7 +238,9 @@ imports:
   subpackages:
   - query
 - name: github.com/google/gofuzz
-  version: 44d81051d367757e1c7c6a5a86423ece9afcf63c
+  version: bbcb9da2d746f8bdbd6a936686a0a6067ada0ec5
+- name: github.com/googleapis/gax-go
+  version: 9af46dd5a1713e8b5cd71106287eba3cefdde50b
 - name: github.com/gorilla/context
   version: 1ea25387ff6f684839d82767c1733ff4d4d15d0a
 - name: github.com/gorilla/websocket
@@ -266,7 +271,7 @@ imports:
 - name: github.com/mailgun/timetools
   version: fd192d755b00c968d312d23f521eb0cdc6f66bd0
 - name: github.com/mailru/easyjson
-  version: 9d6630dc8c577b56cb9687a9cf9e8578aca7298a
+  version: d5b7844b561a7bc640052f1b935f7b800330d7e0
   subpackages:
   - buffer
   - jlexer
@@ -320,7 +325,7 @@ imports:
   subpackages:
   - ovh
 - name: github.com/pborman/uuid
-  version: 5007efa264d92316c43112bc573e754bc889b7b1
+  version: ca53cad383cad2479bbba7f7a1a05797ec1386e4
 - name: github.com/pkg/errors
   version: bfd5150e4e41705ded2129ec33379de1cb90b513
 - name: github.com/pmezard/go-difflib
@@ -344,7 +349,7 @@ imports:
 - name: github.com/prometheus/procfs
   version: 454a56f35412459b5e684fd5ec0f9211b94f002a
 - name: github.com/PuerkitoBio/purell
-  version: 0bcb03f4b4d0a9428594752bd2a3b9aa0a9d4bd4
+  version: 8a290539e2e8629dbc4e6bad948158f790ec31f4
 - name: github.com/PuerkitoBio/urlesc
   version: 5bd2802263f21d8788851d5305584c82a5c75d7e
 - name: github.com/pyr/egoscale
@@ -366,7 +371,7 @@ imports:
 - name: github.com/Sirupsen/logrus
   version: a283a10442df8dc09befd873fab202bf8a253d6a
 - name: github.com/spf13/pflag
-  version: 5644820622454e71517561946e3d94b9f9db6842
+  version: 5ccb023bc27df288a957c5e994cd44fd19619465
 - name: github.com/streamrail/concurrent-map
   version: 65a174a3a4188c0b7099acbc6cfa0c53628d3287
 - name: github.com/stretchr/objx
@@ -415,12 +420,8 @@ imports:
   - plugin
   - plugin/rewrite
   - router
-- name: github.com/weppos/dnsimple-go
-  version: 65c1ca73cb19baf0f8b2b33219b7f57595a3ccb0
-  subpackages:
-  - dnsimple
 - name: github.com/xenolf/lego
-  version: ce8fb060cb8361a9ff8b5fb7c2347fa907b6fcac
+  version: 5dfe609afb1ebe9da97c9846d97a55415e5a5ccd
   subpackages:
   - acme
   - providers/dns
@@ -458,11 +459,13 @@ imports:
   - http2
   - http2/hpack
   - idna
+  - internal/timeseries
   - lex/httplex
   - proxy
   - publicsuffix
+  - trace
 - name: golang.org/x/oauth2
-  version: 3046bc76d6dfd7d3707f6640f85e42d9c4050f50
+  version: 7fdf09982454086d5570c7db3e11f360194830ca
   subpackages:
   - google
   - internal
@@ -474,12 +477,16 @@ imports:
   - unix
   - windows
 - name: golang.org/x/text
-  version: a49bea13b776691cb1b49873e5d8df96ec74831a
+  version: 2910a502d2bf9e43193af9d68ca516529614eed3
-  repo: https://github.com/golang/text.git
-  vcs: git
   subpackages:
-  - .
+  - cases
+  - internal/tag
+  - language
+  - runes
+  - secure/bidirule
+  - secure/precis
   - transform
+  - unicode/bidi
   - unicode/norm
   - width
 - name: google.golang.org/api
@@ -490,7 +497,7 @@ imports:
   - googleapi
   - googleapi/internal/uritemplates
 - name: google.golang.org/appengine
-  version: 12d5545dc1cfa6047a286d5e853841b6471f4c19
+  version: 4f7eeb5305a4ba1966344836ba4af9996b7b4e05
   subpackages:
   - internal
   - internal/app_identity
@@ -501,11 +508,20 @@ imports:
   - internal/remote_api
   - internal/urlfetch
   - urlfetch
-- name: google.golang.org/cloud
+- name: google.golang.org/grpc
-  version: f20d6dcccb44ed49de45ae3703312cb46e627db1
+  version: cdee119ee21e61eef7093a41ba148fa83585e143
   subpackages:
-  - compute/metadata
+  - codes
+  - credentials
+  - grpclog
   - internal
+  - keepalive
+  - metadata
+  - naming
+  - peer
+  - stats
+  - tap
+  - transport
 - name: gopkg.in/fsnotify.v1
   version: a8a77c9133d2d6fd8334f3260d06f60e8d80a5fb
 - name: gopkg.in/inf.v0
@@ -531,111 +547,115 @@ imports:
   - cipher
   - json
 - name: gopkg.in/yaml.v2
-  version: bef53efd0c76e49e6de55ead051f886bea7e9420
+  version: 53feefa2559fb8dfa8d81baad31be332c97d6c77
 - name: k8s.io/client-go
-  version: 1195e3a8ee1a529d53eed7c624527a68555ddf1f
+  version: e121606b0d09b2e1c467183ee46217fa85a6b672
   subpackages:
-  - 1.5/discovery
+  - discovery
-  - 1.5/kubernetes
+  - kubernetes
-  - 1.5/kubernetes/typed/apps/v1alpha1
+  - kubernetes/typed/apps/v1beta1
-  - 1.5/kubernetes/typed/authentication/v1beta1
+  - kubernetes/typed/authentication/v1beta1
-  - 1.5/kubernetes/typed/authorization/v1beta1
+  - kubernetes/typed/authorization/v1beta1
-  - 1.5/kubernetes/typed/autoscaling/v1
+  - kubernetes/typed/autoscaling/v1
-  - 1.5/kubernetes/typed/batch/v1
+  - kubernetes/typed/batch/v1
-  - 1.5/kubernetes/typed/certificates/v1alpha1
+  - kubernetes/typed/batch/v2alpha1
-  - 1.5/kubernetes/typed/core/v1
+  - kubernetes/typed/certificates/v1alpha1
-  - 1.5/kubernetes/typed/extensions/v1beta1
+  - kubernetes/typed/core/v1
-  - 1.5/kubernetes/typed/policy/v1alpha1
+  - kubernetes/typed/extensions/v1beta1
-  - 1.5/kubernetes/typed/rbac/v1alpha1
+  - kubernetes/typed/policy/v1beta1
-  - 1.5/kubernetes/typed/storage/v1beta1
+  - kubernetes/typed/rbac/v1alpha1
-  - 1.5/pkg/api
+  - kubernetes/typed/storage/v1beta1
-  - 1.5/pkg/api/errors
+  - pkg/api
-  - 1.5/pkg/api/install
+  - pkg/api/errors
-  - 1.5/pkg/api/meta
+  - pkg/api/install
-  - 1.5/pkg/api/meta/metatypes
+  - pkg/api/meta
-  - 1.5/pkg/api/resource
+  - pkg/api/meta/metatypes
-  - 1.5/pkg/api/unversioned
+  - pkg/api/resource
-  - 1.5/pkg/api/v1
+  - pkg/api/unversioned
-  - 1.5/pkg/api/validation/path
+  - pkg/api/v1
-  - 1.5/pkg/apimachinery
+  - pkg/api/validation/path
-  - 1.5/pkg/apimachinery/announced
+  - pkg/apimachinery
-  - 1.5/pkg/apimachinery/registered
+  - pkg/apimachinery/announced
-  - 1.5/pkg/apis/apps
+  - pkg/apimachinery/registered
-  - 1.5/pkg/apis/apps/install
+  - pkg/apis/apps
-  - 1.5/pkg/apis/apps/v1alpha1
+  - pkg/apis/apps/install
-  - 1.5/pkg/apis/authentication
+  - pkg/apis/apps/v1beta1
-  - 1.5/pkg/apis/authentication/install
+  - pkg/apis/authentication
-  - 1.5/pkg/apis/authentication/v1beta1
+  - pkg/apis/authentication/install
-  - 1.5/pkg/apis/authorization
+  - pkg/apis/authentication/v1beta1
-  - 1.5/pkg/apis/authorization/install
+  - pkg/apis/authorization
-  - 1.5/pkg/apis/authorization/v1beta1
+  - pkg/apis/authorization/install
-  - 1.5/pkg/apis/autoscaling
+  - pkg/apis/authorization/v1beta1
-  - 1.5/pkg/apis/autoscaling/install
+  - pkg/apis/autoscaling
-  - 1.5/pkg/apis/autoscaling/v1
+  - pkg/apis/autoscaling/install
-  - 1.5/pkg/apis/batch
+  - pkg/apis/autoscaling/v1
-  - 1.5/pkg/apis/batch/install
+  - pkg/apis/batch
-  - 1.5/pkg/apis/batch/v1
+  - pkg/apis/batch/install
-  - 1.5/pkg/apis/batch/v2alpha1
+  - pkg/apis/batch/v1
-  - 1.5/pkg/apis/certificates
+  - pkg/apis/batch/v2alpha1
-  - 1.5/pkg/apis/certificates/install
+  - pkg/apis/certificates
-  - 1.5/pkg/apis/certificates/v1alpha1
+  - pkg/apis/certificates/install
-  - 1.5/pkg/apis/extensions
+  - pkg/apis/certificates/v1alpha1
-  - 1.5/pkg/apis/extensions/install
+  - pkg/apis/extensions
-  - 1.5/pkg/apis/extensions/v1beta1
+  - pkg/apis/extensions/install
-  - 1.5/pkg/apis/policy
+  - pkg/apis/extensions/v1beta1
-  - 1.5/pkg/apis/policy/install
+  - pkg/apis/policy
-  - 1.5/pkg/apis/policy/v1alpha1
+  - pkg/apis/policy/install
-  - 1.5/pkg/apis/rbac
+  - pkg/apis/policy/v1beta1
-  - 1.5/pkg/apis/rbac/install
+  - pkg/apis/rbac
-  - 1.5/pkg/apis/rbac/v1alpha1
+  - pkg/apis/rbac/install
-  - 1.5/pkg/apis/storage
+  - pkg/apis/rbac/v1alpha1
-  - 1.5/pkg/apis/storage/install
+  - pkg/apis/storage
-  - 1.5/pkg/apis/storage/v1beta1
+  - pkg/apis/storage/install
-  - 1.5/pkg/auth/user
+  - pkg/apis/storage/v1beta1
-  - 1.5/pkg/conversion
+  - pkg/auth/user
-  - 1.5/pkg/conversion/queryparams
+  - pkg/conversion
-  - 1.5/pkg/fields
+  - pkg/conversion/queryparams
-  - 1.5/pkg/genericapiserver/openapi/common
+  - pkg/fields
-  - 1.5/pkg/labels
+  - pkg/genericapiserver/openapi/common
-  - 1.5/pkg/runtime
+  - pkg/labels
-  - 1.5/pkg/runtime/serializer
+  - pkg/runtime
-  - 1.5/pkg/runtime/serializer/json
+  - pkg/runtime/serializer
-  - 1.5/pkg/runtime/serializer/protobuf
+  - pkg/runtime/serializer/json
-  - 1.5/pkg/runtime/serializer/recognizer
+  - pkg/runtime/serializer/protobuf
-  - 1.5/pkg/runtime/serializer/streaming
+  - pkg/runtime/serializer/recognizer
-  - 1.5/pkg/runtime/serializer/versioning
+  - pkg/runtime/serializer/streaming
-  - 1.5/pkg/selection
+  - pkg/runtime/serializer/versioning
-  - 1.5/pkg/third_party/forked/golang/reflect
+  - pkg/selection
-  - 1.5/pkg/types
+  - pkg/third_party/forked/golang/reflect
-  - 1.5/pkg/util
+  - pkg/third_party/forked/golang/template
-  - 1.5/pkg/util/cert
+  - pkg/types
-  - 1.5/pkg/util/clock
+  - pkg/util
-  - 1.5/pkg/util/errors
+  - pkg/util/cert
-  - 1.5/pkg/util/flowcontrol
+  - pkg/util/clock
-  - 1.5/pkg/util/framer
+  - pkg/util/diff
-  - 1.5/pkg/util/integer
+  - pkg/util/errors
-  - 1.5/pkg/util/intstr
+  - pkg/util/flowcontrol
-  - 1.5/pkg/util/json
+  - pkg/util/framer
-  - 1.5/pkg/util/labels
+  - pkg/util/integer
-  - 1.5/pkg/util/net
+  - pkg/util/intstr
-  - 1.5/pkg/util/parsers
+  - pkg/util/json
-  - 1.5/pkg/util/rand
+  - pkg/util/jsonpath
-  - 1.5/pkg/util/runtime
+  - pkg/util/labels
-  - 1.5/pkg/util/sets
+  - pkg/util/net
-  - 1.5/pkg/util/uuid
+  - pkg/util/parsers
-  - 1.5/pkg/util/validation
+  - pkg/util/rand
-  - 1.5/pkg/util/validation/field
+  - pkg/util/runtime
-  - 1.5/pkg/util/wait
+  - pkg/util/sets
-  - 1.5/pkg/util/yaml
+  - pkg/util/uuid
-  - 1.5/pkg/version
+  - pkg/util/validation
-  - 1.5/pkg/watch
+  - pkg/util/validation/field
-  - 1.5/pkg/watch/versioned
+  - pkg/util/wait
-  - 1.5/plugin/pkg/client/auth
+  - pkg/util/yaml
-  - 1.5/plugin/pkg/client/auth/gcp
+  - pkg/version
-  - 1.5/plugin/pkg/client/auth/oidc
+  - pkg/watch
-  - 1.5/rest
+  - pkg/watch/versioned
-  - 1.5/tools/cache
+  - plugin/pkg/client/auth
-  - 1.5/tools/clientcmd/api
+  - plugin/pkg/client/auth/gcp
-  - 1.5/tools/metrics
+  - plugin/pkg/client/auth/oidc
-  - 1.5/transport
+  - rest
+  - tools/cache
+  - tools/clientcmd/api
+  - tools/metrics
+  - transport
 testImports: []

glide.yaml

@@ -60,7 +60,7 @@ import:
   subpackages:
   - plugin/rewrite
 - package: github.com/xenolf/lego
-  version: ce8fb060cb8361a9ff8b5fb7c2347fa907b6fcac
+  version: 5dfe609afb1ebe9da97c9846d97a55415e5a5ccd
   subpackages:
   - acme
 - package: gopkg.in/fsnotify.v1
@@ -89,7 +89,7 @@ import:
 - package: github.com/satori/go.uuid
   version: ^1.1.0
 - package: k8s.io/client-go
-  version: ^v1.5.0
+  version: v2.0.0
 - package: github.com/gambol99/go-marathon
   version: ^0.5.1
 - package: github.com/ArthurHlt/go-eureka-client
@@ -131,7 +131,7 @@ import:
   - service/ec2
   - service/ecs
 - package: cloud.google.com/go
-  version: v0.6.0
+  version: v0.7.0
   subpackages:
   - compute/metadata
 - package: github.com/gogo/protobuf
@@ -140,3 +140,9 @@ import:
   - proto
 - package: github.com/rancher/go-rancher
   version: 2c43ff300f3eafcbd7d0b89b10427fc630efdc1e
+- package: golang.org/x/oauth2/google
+  version: 7fdf09982454086d5570c7db3e11f360194830ca
+- package: github.com/googleapis/gax-go
+  version: 9af46dd5a1713e8b5cd71106287eba3cefdde50b
+- package: google.golang.org/grpc
+  version: v1.2.0

provider/k8s/client.go

@@ -6,16 +6,16 @@ import (
 	"io/ioutil"
 	"time"
 
-	"k8s.io/client-go/1.5/kubernetes"
+	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/1.5/pkg/api"
+	"k8s.io/client-go/pkg/api"
-	"k8s.io/client-go/1.5/pkg/api/v1"
+	"k8s.io/client-go/pkg/api/v1"
-	"k8s.io/client-go/1.5/pkg/apis/extensions/v1beta1"
+	"k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	"k8s.io/client-go/1.5/pkg/fields"
+	"k8s.io/client-go/pkg/fields"
-	"k8s.io/client-go/1.5/pkg/labels"
+	"k8s.io/client-go/pkg/labels"
-	"k8s.io/client-go/1.5/pkg/runtime"
+	"k8s.io/client-go/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/watch"
+	"k8s.io/client-go/pkg/watch"
-	"k8s.io/client-go/1.5/rest"
+	"k8s.io/client-go/rest"
-	"k8s.io/client-go/1.5/tools/cache"
+	"k8s.io/client-go/tools/cache"
 )
 
 const resyncPeriod = time.Minute * 5
@@ -111,7 +111,7 @@ func (c *clientImpl) GetIngresses(namespaces Namespaces) []*v1beta1.Ingress {
 // WatchIngresses starts the watch of Kubernetes Ingresses resources and updates the corresponding store
 func (c *clientImpl) WatchIngresses(labelSelector labels.Selector, watchCh chan<- interface{}, stopCh <-chan struct{}) {
 	source := NewListWatchFromClient(
-		c.clientset.ExtensionsClient,
+		c.clientset.ExtensionsV1beta1().RESTClient(),
 		"ingresses",
 		api.NamespaceAll,
 		fields.Everything(),
@@ -157,7 +157,7 @@ func (c *clientImpl) GetService(namespace, name string) (*v1.Service, bool, erro
 // WatchServices starts the watch of Kubernetes Service resources and updates the corresponding store
 func (c *clientImpl) WatchServices(watchCh chan<- interface{}, stopCh <-chan struct{}) {
 	source := cache.NewListWatchFromClient(
-		c.clientset.CoreClient,
+		c.clientset.CoreV1().RESTClient(),
 		"services",
 		api.NamespaceAll,
 		fields.Everything())
@@ -186,7 +186,7 @@ func (c *clientImpl) GetEndpoints(namespace, name string) (*v1.Endpoints, bool,
 // WatchEndpoints starts the watch of Kubernetes Endpoints resources and updates the corresponding store
 func (c *clientImpl) WatchEndpoints(watchCh chan<- interface{}, stopCh <-chan struct{}) {
 	source := cache.NewListWatchFromClient(
-		c.clientset.CoreClient,
+		c.clientset.CoreV1().RESTClient(),
 		"endpoints",
 		api.NamespaceAll,
 		fields.Everything())

provider/kubernetes.go

@@ -15,8 +15,8 @@ import (
 	"github.com/containous/traefik/provider/k8s"
 	"github.com/containous/traefik/safe"
 	"github.com/containous/traefik/types"
-	"k8s.io/client-go/1.5/pkg/api/v1"
+	"k8s.io/client-go/pkg/api/v1"
-	"k8s.io/client-go/1.5/pkg/util/intstr"
+	"k8s.io/client-go/pkg/util/intstr"
 )
 
 var _ Provider = (*Kubernetes)(nil)

provider/kubernetes_test.go

@@ -9,9 +9,9 @@ import (
 
 	"github.com/containous/traefik/provider/k8s"
 	"github.com/containous/traefik/types"
-	"k8s.io/client-go/1.5/pkg/api/v1"
+	"k8s.io/client-go/pkg/api/v1"
-	"k8s.io/client-go/1.5/pkg/apis/extensions/v1beta1"
+	"k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	"k8s.io/client-go/1.5/pkg/util/intstr"
+	"k8s.io/client-go/pkg/util/intstr"
 )
 
 func TestLoadIngresses(t *testing.T) {

vendor/cloud.google.com/go/internal/cloud.go

@@ -0,0 +1,64 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package internal provides support for the cloud packages.
+//
+// Users should not import this package directly.
+package internal
+
+import (
+	"fmt"
+	"net/http"
+)
+
+const userAgent = "gcloud-golang/0.1"
+
+// Transport is an http.RoundTripper that appends Google Cloud client's
+// user-agent to the original request's user-agent header.
+type Transport struct {
+	// TODO(bradfitz): delete internal.Transport. It's too wrappy for what it does.
+	// Do User-Agent some other way.
+
+	// Base is the actual http.RoundTripper
+	// requests will use. It must not be nil.
+	Base http.RoundTripper
+}
+
+// RoundTrip appends a user-agent to the existing user-agent
+// header and delegates the request to the base http.RoundTripper.
+func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
+	req = cloneRequest(req)
+	ua := req.Header.Get("User-Agent")
+	if ua == "" {
+		ua = userAgent
+	} else {
+		ua = fmt.Sprintf("%s %s", ua, userAgent)
+	}
+	req.Header.Set("User-Agent", ua)
+	return t.Base.RoundTrip(req)
+}
+
+// cloneRequest returns a clone of the provided *http.Request.
+// The clone is a shallow copy of the struct and its Header map.
+func cloneRequest(r *http.Request) *http.Request {
+	// shallow copy of the struct
+	r2 := new(http.Request)
+	*r2 = *r
+	// deep copy of the Header
+	r2.Header = make(http.Header)
+	for k, s := range r.Header {
+		r2.Header[k] = s
+	}
+	return r2
+}

vendor/cloud.google.com/go/internal/retry.go

@@ -0,0 +1,55 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package internal
+
+import (
+	"fmt"
+	"time"
+
+	gax "github.com/googleapis/gax-go"
+
+	"golang.org/x/net/context"
+)
+
+// Retry calls the supplied function f repeatedly according to the provided
+// backoff parameters. It returns when one of the following occurs:
+// When f's first return value is true, Retry immediately returns with f's second
+// return value.
+// When the provided context is done, Retry returns with ctx.Err().
+func Retry(ctx context.Context, bo gax.Backoff, f func() (stop bool, err error)) error {
+	return retry(ctx, bo, f, gax.Sleep)
+}
+
+func retry(ctx context.Context, bo gax.Backoff, f func() (stop bool, err error),
+	sleep func(context.Context, time.Duration) error) error {
+	var lastErr error
+	for {
+		stop, err := f()
+		if stop {
+			return err
+		}
+		// Remember the last "real" error from f.
+		if err != nil && err != context.Canceled && err != context.DeadlineExceeded {
+			lastErr = err
+		}
+		p := bo.Pause()
+		if cerr := sleep(ctx, p); cerr != nil {
+			if lastErr != nil {
+				return fmt.Errorf("%v; last function err: %v", cerr, lastErr)
+			}
+			return cerr
+		}
+	}
+}

vendor/github.com/Azure/azure-sdk-for-go/arm/dns/client.go

@@ -17,7 +17,7 @@ package dns
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// Code generated by Microsoft (R) AutoRest Code Generator 0.17.0.0
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
 // Changes may cause incorrect behavior and will be lost if the code is
 // regenerated.
 
@@ -26,9 +26,6 @@ import (
 )
 
 const (
-	// APIVersion is the version of the Dns
-	APIVersion = "2016-04-01"
-
 	// DefaultBaseURI is the default URI used for the service Dns
 	DefaultBaseURI = "https://management.azure.com"
 )
@@ -37,7 +34,6 @@ const (
 type ManagementClient struct {
 	autorest.Client
 	BaseURI        string
-	APIVersion     string
 	SubscriptionID string
 }
 
@@ -51,7 +47,6 @@ func NewWithBaseURI(baseURI string, subscriptionID string) ManagementClient {
 	return ManagementClient{
 		Client:         autorest.NewClientWithUserAgent(UserAgent()),
 		BaseURI:        baseURI,
-		APIVersion:     APIVersion,
 		SubscriptionID: subscriptionID,
 	}
 }

vendor/github.com/Azure/azure-sdk-for-go/arm/dns/models.go

@@ -14,7 +14,7 @@ package dns
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// Code generated by Microsoft (R) AutoRest Code Generator 0.17.0.0
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
 // Changes may cause incorrect behavior and will be lost if the code is
 // regenerated.
 
@@ -42,8 +42,8 @@ const (
 	Continue HTTPStatusCode = "Continue"
 	// Created specifies the created state for http status code.
 	Created HTTPStatusCode = "Created"
-	// ExpectationFailed specifies the expectation failed state for http
+	// ExpectationFailed specifies the expectation failed state for http status
-	// status code.
+	// code.
 	ExpectationFailed HTTPStatusCode = "ExpectationFailed"
 	// Forbidden specifies the forbidden state for http status code.
 	Forbidden HTTPStatusCode = "Forbidden"
@@ -126,13 +126,13 @@ const (
 	// SwitchingProtocols specifies the switching protocols state for http
 	// status code.
 	SwitchingProtocols HTTPStatusCode = "SwitchingProtocols"
-	// TemporaryRedirect specifies the temporary redirect state for http
+	// TemporaryRedirect specifies the temporary redirect state for http status
-	// status code.
+	// code.
 	TemporaryRedirect HTTPStatusCode = "TemporaryRedirect"
 	// Unauthorized specifies the unauthorized state for http status code.
 	Unauthorized HTTPStatusCode = "Unauthorized"
-	// UnsupportedMediaType specifies the unsupported media type state for
+	// UnsupportedMediaType specifies the unsupported media type state for http
-	// http status code.
+	// status code.
 	UnsupportedMediaType HTTPStatusCode = "UnsupportedMediaType"
 	// Unused specifies the unused state for http status code.
 	Unused HTTPStatusCode = "Unused"
@@ -259,14 +259,14 @@ type RecordSetProperties struct {
 	Metadata    *map[string]*string `json:"metadata,omitempty"`
 	TTL         *int64              `json:"TTL,omitempty"`
 	ARecords    *[]ARecord          `json:"ARecords,omitempty"`
-	AAAARecords *[]AaaaRecord       `json:"AAAARecords,omitempty"`
+	AaaaRecords *[]AaaaRecord       `json:"AAAARecords,omitempty"`
-	MXRecords   *[]MxRecord         `json:"MXRecords,omitempty"`
+	MxRecords   *[]MxRecord         `json:"MXRecords,omitempty"`
-	NSRecords   *[]NsRecord         `json:"NSRecords,omitempty"`
+	NsRecords   *[]NsRecord         `json:"NSRecords,omitempty"`
-	PTRRecords  *[]PtrRecord        `json:"PTRRecords,omitempty"`
+	PtrRecords  *[]PtrRecord        `json:"PTRRecords,omitempty"`
-	SRVRecords  *[]SrvRecord        `json:"SRVRecords,omitempty"`
+	SrvRecords  *[]SrvRecord        `json:"SRVRecords,omitempty"`
-	TXTRecords  *[]TxtRecord        `json:"TXTRecords,omitempty"`
+	TxtRecords  *[]TxtRecord        `json:"TXTRecords,omitempty"`
-	CNAMERecord *CnameRecord        `json:"CNAMERecord,omitempty"`
+	CnameRecord *CnameRecord        `json:"CNAMERecord,omitempty"`
-	SOARecord   *SoaRecord          `json:"SOARecord,omitempty"`
+	SoaRecord   *SoaRecord          `json:"SOARecord,omitempty"`
 }
 
 // RecordSetUpdateParameters is parameters supplied to update a record set.

vendor/github.com/Azure/azure-sdk-for-go/arm/dns/recordsets.go

@@ -14,7 +14,7 @@ package dns
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// Code generated by Microsoft (R) AutoRest Code Generator 0.17.0.0
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
 // Changes may cause incorrect behavior and will be lost if the code is
 // regenerated.
 
@@ -42,18 +42,17 @@ func NewRecordSetsClientWithBaseURI(baseURI string, subscriptionID string) Recor
 
 // CreateOrUpdate creates or updates a record set within a DNS zone.
 //
-// resourceGroupName is the name of the resource group. zoneName is the name
+// resourceGroupName is the name of the resource group. zoneName is the name of
-// of the DNS zone (without a terminating dot). relativeRecordSetName is the
+// the DNS zone (without a terminating dot). relativeRecordSetName is the name
-// name of the record set, relative to the name of the zone. recordType is
+// of the record set, relative to the name of the zone. recordType is the type
-// the type of DNS record in this record set. Record sets of type SOA can be
+// of DNS record in this record set. Record sets of type SOA can be updated but
-// updated but not created (they are created when the DNS zone is created).
+// not created (they are created when the DNS zone is created). parameters is
-// Possible values include: 'A', 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', 'SOA',
+// parameters supplied to the CreateOrUpdate operation. ifMatch is the etag of
-// 'SRV', 'TXT' parameters is parameters supplied to the CreateOrUpdate
+// the record set. Omit this value to always overwrite the current record set.
-// operation. ifMatch is the etag of the record set. Omit this value to
+// Specify the last-seen etag value to prevent accidentally overwritting any
-// always overwrite the current record set. Specify the last-seen etag value
+// concurrent changes. ifNoneMatch is set to '*' to allow a new record set to
-// to prevent accidentally overwritting any concurrent changes. ifNoneMatch
+// be created, but to prevent updating an existing record set. Other values
-// is set to '*' to allow a new record set to be created, but to prevent
+// will be ignored.
-// updating an existing record set. Other values will be ignored.
 func (client RecordSetsClient) CreateOrUpdate(resourceGroupName string, zoneName string, relativeRecordSetName string, recordType RecordType, parameters RecordSet, ifMatch string, ifNoneMatch string) (result RecordSet, err error) {
 	req, err := client.CreateOrUpdatePreparer(resourceGroupName, zoneName, relativeRecordSetName, recordType, parameters, ifMatch, ifNoneMatch)
 	if err != nil {
@@ -84,8 +83,9 @@ func (client RecordSetsClient) CreateOrUpdatePreparer(resourceGroupName string,
 		"zoneName":              autorest.Encode("path", zoneName),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 
 	preparer := autorest.CreatePreparer(
@@ -128,15 +128,14 @@ func (client RecordSetsClient) CreateOrUpdateResponder(resp *http.Response) (res
 // Delete deletes a record set from a DNS zone. This operation cannot be
 // undone.
 //
-// resourceGroupName is the name of the resource group. zoneName is the name
+// resourceGroupName is the name of the resource group. zoneName is the name of
-// of the DNS zone (without a terminating dot). relativeRecordSetName is the
+// the DNS zone (without a terminating dot). relativeRecordSetName is the name
-// name of the record set, relative to the name of the zone. recordType is
+// of the record set, relative to the name of the zone. recordType is the type
-// the type of DNS record in this record set. Record sets of type SOA cannot
+// of DNS record in this record set. Record sets of type SOA cannot be deleted
-// be deleted (they are deleted when the DNS zone is deleted). Possible
+// (they are deleted when the DNS zone is deleted). ifMatch is the etag of the
-// values include: 'A', 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', 'SOA', 'SRV',
+// record set. Omit this value to always delete the current record set. Specify
-// 'TXT' ifMatch is the etag of the record set. Omit this value to always
+// the last-seen etag value to prevent accidentally deleting any concurrent
-// delete the current record set. Specify the last-seen etag value to prevent
+// changes.
-// accidentally deleting any concurrent changes.
 func (client RecordSetsClient) Delete(resourceGroupName string, zoneName string, relativeRecordSetName string, recordType RecordType, ifMatch string) (result autorest.Response, err error) {
 	req, err := client.DeletePreparer(resourceGroupName, zoneName, relativeRecordSetName, recordType, ifMatch)
 	if err != nil {
@@ -167,8 +166,9 @@ func (client RecordSetsClient) DeletePreparer(resourceGroupName string, zoneName
 		"zoneName":              autorest.Encode("path", zoneName),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 
 	preparer := autorest.CreatePreparer(
@@ -203,11 +203,10 @@ func (client RecordSetsClient) DeleteResponder(resp *http.Response) (result auto
 
 // Get gets a record set.
 //
-// resourceGroupName is the name of the resource group. zoneName is the name
+// resourceGroupName is the name of the resource group. zoneName is the name of
-// of the DNS zone (without a terminating dot). relativeRecordSetName is the
+// the DNS zone (without a terminating dot). relativeRecordSetName is the name
-// name of the record set, relative to the name of the zone. recordType is
+// of the record set, relative to the name of the zone. recordType is the type
-// the type of DNS record in this record set. Possible values include: 'A',
+// of DNS record in this record set.
-// 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT'
 func (client RecordSetsClient) Get(resourceGroupName string, zoneName string, relativeRecordSetName string, recordType RecordType) (result RecordSet, err error) {
 	req, err := client.GetPreparer(resourceGroupName, zoneName, relativeRecordSetName, recordType)
 	if err != nil {
@@ -238,8 +237,9 @@ func (client RecordSetsClient) GetPreparer(resourceGroupName string, zoneName st
 		"zoneName":              autorest.Encode("path", zoneName),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 
 	preparer := autorest.CreatePreparer(
@@ -271,8 +271,8 @@ func (client RecordSetsClient) GetResponder(resp *http.Response) (result RecordS
 
 // ListByDNSZone lists all record sets in a DNS zone.
 //
-// resourceGroupName is the name of the resource group. zoneName is the name
+// resourceGroupName is the name of the resource group. zoneName is the name of
-// of the DNS zone (without a terminating dot). top is the maximum number of
+// the DNS zone (without a terminating dot). top is the maximum number of
 // record sets to return. If not specified, returns up to 100 record sets.
 func (client RecordSetsClient) ListByDNSZone(resourceGroupName string, zoneName string, top *int32) (result RecordSetListResult, err error) {
 	req, err := client.ListByDNSZonePreparer(resourceGroupName, zoneName, top)
@@ -302,8 +302,9 @@ func (client RecordSetsClient) ListByDNSZonePreparer(resourceGroupName string, z
 		"zoneName":          autorest.Encode("path", zoneName),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 	if top != nil {
 		queryParameters["$top"] = autorest.Encode("query", *top)
@@ -362,11 +363,10 @@ func (client RecordSetsClient) ListByDNSZoneNextResults(lastResults RecordSetLis
 
 // ListByType lists the record sets of a specified type in a DNS zone.
 //
-// resourceGroupName is the name of the resource group. zoneName is the name
+// resourceGroupName is the name of the resource group. zoneName is the name of
-// of the DNS zone (without a terminating dot). recordType is the type of
+// the DNS zone (without a terminating dot). recordType is the type of record
-// record sets to enumerate. Possible values include: 'A', 'AAAA', 'CNAME',
+// sets to enumerate. top is the maximum number of record sets to return. If
-// 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT' top is the maximum number of record
+// not specified, returns up to 100 record sets.
-// sets to return. If not specified, returns up to 100 record sets.
 func (client RecordSetsClient) ListByType(resourceGroupName string, zoneName string, recordType RecordType, top *int32) (result RecordSetListResult, err error) {
 	req, err := client.ListByTypePreparer(resourceGroupName, zoneName, recordType, top)
 	if err != nil {
@@ -396,8 +396,9 @@ func (client RecordSetsClient) ListByTypePreparer(resourceGroupName string, zone
 		"zoneName":          autorest.Encode("path", zoneName),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 	if top != nil {
 		queryParameters["$top"] = autorest.Encode("query", *top)
@@ -456,15 +457,13 @@ func (client RecordSetsClient) ListByTypeNextResults(lastResults RecordSetListRe
 
 // Update updates a record set within a DNS zone.
 //
-// resourceGroupName is the name of the resource group. zoneName is the name
+// resourceGroupName is the name of the resource group. zoneName is the name of
-// of the DNS zone (without a terminating dot). relativeRecordSetName is the
+// the DNS zone (without a terminating dot). relativeRecordSetName is the name
-// name of the record set, relative to the name of the zone. recordType is
+// of the record set, relative to the name of the zone. recordType is the type
-// the type of DNS record in this record set. Possible values include: 'A',
+// of DNS record in this record set. parameters is parameters supplied to the
-// 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT' parameters is
+// Update operation. ifMatch is the etag of the record set. Omit this value to
-// parameters supplied to the Update operation. ifMatch is the etag of the
+// always overwrite the current record set. Specify the last-seen etag value to
-// record set. Omit this value to always overwrite the current record set.
+// prevent accidentally overwritting concurrent changes.
-// Specify the last-seen etag value to prevent accidentally overwritting
-// concurrent changes.
 func (client RecordSetsClient) Update(resourceGroupName string, zoneName string, relativeRecordSetName string, recordType RecordType, parameters RecordSet, ifMatch string) (result RecordSet, err error) {
 	req, err := client.UpdatePreparer(resourceGroupName, zoneName, relativeRecordSetName, recordType, parameters, ifMatch)
 	if err != nil {
@@ -495,8 +494,9 @@ func (client RecordSetsClient) UpdatePreparer(resourceGroupName string, zoneName
 		"zoneName":              autorest.Encode("path", zoneName),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 
 	preparer := autorest.CreatePreparer(

vendor/github.com/Azure/azure-sdk-for-go/arm/dns/version.go

@@ -14,30 +14,16 @@ package dns
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// Code generated by Microsoft (R) AutoRest Code Generator 0.17.0.0
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
 // Changes may cause incorrect behavior and will be lost if the code is
 // regenerated.
 
-import (
-	"fmt"
-)
-
-const (
-	major = "7"
-	minor = "0"
-	patch = "1"
-	// Always begin a "tag" with a dash (as per http://semver.org)
-	tag             = "-beta"
-	semVerFormat    = "%s.%s.%s%s"
-	userAgentFormat = "Azure-SDK-for-Go/%s arm-%s/%s"
-)
-
 // UserAgent returns the UserAgent string to use when sending http.Requests.
 func UserAgent() string {
-	return fmt.Sprintf(userAgentFormat, Version(), "dns", "2016-04-01")
+	return "Azure-SDK-For-Go/v9.0.0-beta arm-dns/2016-04-01"
 }
 
 // Version returns the semantic version (see http://semver.org) of the client.
 func Version() string {
-	return fmt.Sprintf(semVerFormat, major, minor, patch, tag)
+	return "v9.0.0-beta"
 }

vendor/github.com/Azure/azure-sdk-for-go/arm/dns/zones.go

@@ -14,14 +14,13 @@ package dns
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// Code generated by Microsoft (R) AutoRest Code Generator 0.17.0.0
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
 // Changes may cause incorrect behavior and will be lost if the code is
 // regenerated.
 
 import (
 	"github.com/Azure/go-autorest/autorest"
 	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
 	"net/http"
 )
 
@@ -43,21 +42,14 @@ func NewZonesClientWithBaseURI(baseURI string, subscriptionID string) ZonesClien
 // CreateOrUpdate creates or updates a DNS zone. Does not modify DNS records
 // within the zone.
 //
-// resourceGroupName is the name of the resource group. zoneName is the name
+// resourceGroupName is the name of the resource group. zoneName is the name of
-// of the DNS zone (without a terminating dot). parameters is parameters
+// the DNS zone (without a terminating dot). parameters is parameters supplied
-// supplied to the CreateOrUpdate operation. ifMatch is the etag of the DNS
+// to the CreateOrUpdate operation. ifMatch is the etag of the DNS zone. Omit
-// zone. Omit this value to always overwrite the current zone. Specify the
+// this value to always overwrite the current zone. Specify the last-seen etag
-// last-seen etag value to prevent accidentally overwritting any concurrent
+// value to prevent accidentally overwritting any concurrent changes.
-// changes. ifNoneMatch is set to '*' to allow a new DNS zone to be created,
+// ifNoneMatch is set to '*' to allow a new DNS zone to be created, but to
-// but to prevent updating an existing zone. Other values will be ignored.
+// prevent updating an existing zone. Other values will be ignored.
 func (client ZonesClient) CreateOrUpdate(resourceGroupName string, zoneName string, parameters Zone, ifMatch string, ifNoneMatch string) (result Zone, err error) {
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: parameters,
-			Constraints: []validation.Constraint{{Target: "parameters.ZoneProperties", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "parameters.ZoneProperties.NameServers", Name: validation.ReadOnly, Rule: true, Chain: nil}}}}}}); err != nil {
-		return result, validation.NewErrorWithValidationError(err, "dns.ZonesClient", "CreateOrUpdate")
-	}
-
 	req, err := client.CreateOrUpdatePreparer(resourceGroupName, zoneName, parameters, ifMatch, ifNoneMatch)
 	if err != nil {
 		return result, autorest.NewErrorWithError(err, "dns.ZonesClient", "CreateOrUpdate", nil, "Failure preparing request")
@@ -85,8 +77,9 @@ func (client ZonesClient) CreateOrUpdatePreparer(resourceGroupName string, zoneN
 		"zoneName":          autorest.Encode("path", zoneName),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 
 	preparer := autorest.CreatePreparer(
@@ -126,15 +119,15 @@ func (client ZonesClient) CreateOrUpdateResponder(resp *http.Response) (result Z
 	return
 }
 
-// Delete deletes a DNS zone. WARNING: All DNS records in the zone will also
+// Delete deletes a DNS zone. WARNING: All DNS records in the zone will also be
-// be deleted. This operation cannot be undone. This method may poll for
+// deleted. This operation cannot be undone. This method may poll for
-// completion. Polling can be canceled by passing the cancel channel
+// completion. Polling can be canceled by passing the cancel channel argument.
-// argument. The channel will be used to cancel polling and any outstanding
+// The channel will be used to cancel polling and any outstanding HTTP
-// HTTP requests.
+// requests.
 //
-// resourceGroupName is the name of the resource group. zoneName is the name
+// resourceGroupName is the name of the resource group. zoneName is the name of
-// of the DNS zone (without a terminating dot). ifMatch is the etag of the
+// the DNS zone (without a terminating dot). ifMatch is the etag of the DNS
-// DNS zone. Omit this value to always delete the current zone. Specify the
+// zone. Omit this value to always delete the current zone. Specify the
 // last-seen etag value to prevent accidentally deleting any concurrent
 // changes.
 func (client ZonesClient) Delete(resourceGroupName string, zoneName string, ifMatch string, cancel <-chan struct{}) (result autorest.Response, err error) {
@@ -165,8 +158,9 @@ func (client ZonesClient) DeletePreparer(resourceGroupName string, zoneName stri
 		"zoneName":          autorest.Encode("path", zoneName),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 
 	preparer := autorest.CreatePreparer(
@@ -204,8 +198,8 @@ func (client ZonesClient) DeleteResponder(resp *http.Response) (result autorest.
 // Get gets a DNS zone. Retrieves the zone properties, but not the record sets
 // within the zone.
 //
-// resourceGroupName is the name of the resource group. zoneName is the name
+// resourceGroupName is the name of the resource group. zoneName is the name of
-// of the DNS zone (without a terminating dot).
+// the DNS zone (without a terminating dot).
 func (client ZonesClient) Get(resourceGroupName string, zoneName string) (result Zone, err error) {
 	req, err := client.GetPreparer(resourceGroupName, zoneName)
 	if err != nil {
@@ -234,8 +228,9 @@ func (client ZonesClient) GetPreparer(resourceGroupName string, zoneName string)
 		"zoneName":          autorest.Encode("path", zoneName),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 
 	preparer := autorest.CreatePreparer(
@@ -295,8 +290,9 @@ func (client ZonesClient) ListPreparer(top *int32) (*http.Request, error) {
 		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 	if top != nil {
 		queryParameters["$top"] = autorest.Encode("query", *top)
@@ -356,8 +352,8 @@ func (client ZonesClient) ListNextResults(lastResults ZoneListResult) (result Zo
 // ListByResourceGroup lists the DNS zones within a resource group.
 //
 // resourceGroupName is the name of the resource group. top is the maximum
-// number of record sets to return. If not specified, returns up to 100
+// number of record sets to return. If not specified, returns up to 100 record
-// record sets.
+// sets.
 func (client ZonesClient) ListByResourceGroup(resourceGroupName string, top *int32) (result ZoneListResult, err error) {
 	req, err := client.ListByResourceGroupPreparer(resourceGroupName, top)
 	if err != nil {
@@ -385,8 +381,9 @@ func (client ZonesClient) ListByResourceGroupPreparer(resourceGroupName string,
 		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
 	}
 
+	const APIVersion = "2016-04-01"
 	queryParameters := map[string]interface{}{
-		"api-version": client.APIVersion,
+		"api-version": APIVersion,
 	}
 	if top != nil {
 		queryParameters["$top"] = autorest.Encode("query", *top)

vendor/github.com/Azure/go-autorest/autorest/autorest.go

@@ -16,6 +16,7 @@ and Responding. A typical pattern is:
     DoRetryForAttempts(5, time.Second))
 
   err = Respond(resp,
+    ByDiscardingBody(),
     ByClosing())
 
 Each phase relies on decorators to modify and / or manage processing. Decorators may first modify

vendor/github.com/Azure/go-autorest/autorest/azure/async.go

@@ -3,12 +3,13 @@ package azure
 import (
 	"bytes"
 	"fmt"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/date"
 	"io/ioutil"
 	"net/http"
 	"strings"
 	"time"
+
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/date"
 )
 
 const (

vendor/github.com/Azure/go-autorest/autorest/azure/environments.go

@@ -35,6 +35,7 @@ type Environment struct {
 	ServiceBusEndpointSuffix     string `json:"serviceBusEndpointSuffix"`
 	ServiceManagementVMDNSSuffix string `json:"serviceManagementVMDNSSuffix"`
 	ResourceManagerVMDNSSuffix   string `json:"resourceManagerVMDNSSuffix"`
+	ContainerRegistryDNSSuffix   string `json:"containerRegistryDNSSuffix"`
 }
 
 var (
@@ -56,6 +57,7 @@ var (
 		ServiceBusEndpointSuffix:     "servicebus.azure.com",
 		ServiceManagementVMDNSSuffix: "cloudapp.net",
 		ResourceManagerVMDNSSuffix:   "cloudapp.azure.com",
+		ContainerRegistryDNSSuffix:   "azurecr.io",
 	}
 
 	// USGovernmentCloud is the cloud environment for the US Government
@@ -76,6 +78,7 @@ var (
 		ServiceBusEndpointSuffix:     "servicebus.usgovcloudapi.net",
 		ServiceManagementVMDNSSuffix: "usgovcloudapp.net",
 		ResourceManagerVMDNSSuffix:   "cloudapp.windowsazure.us",
+		ContainerRegistryDNSSuffix:   "azurecr.io",
 	}
 
 	// ChinaCloud is the cloud environment operated in China
@@ -85,7 +88,7 @@ var (
 		PublishSettingsURL:           "https://manage.chinacloudapi.com/publishsettings/index",
 		ServiceManagementEndpoint:    "https://management.core.chinacloudapi.cn/",
 		ResourceManagerEndpoint:      "https://management.chinacloudapi.cn/",
-		ActiveDirectoryEndpoint:      "https://login.chinacloudapi.cn/?api-version=1.0",
+		ActiveDirectoryEndpoint:      "https://login.chinacloudapi.cn/",
 		GalleryEndpoint:              "https://gallery.chinacloudapi.cn/",
 		KeyVaultEndpoint:             "https://vault.azure.cn/",
 		GraphEndpoint:                "https://graph.chinacloudapi.cn/",
@@ -96,6 +99,7 @@ var (
 		ServiceBusEndpointSuffix:     "servicebus.chinacloudapi.net",
 		ServiceManagementVMDNSSuffix: "chinacloudapp.cn",
 		ResourceManagerVMDNSSuffix:   "cloudapp.azure.cn",
+		ContainerRegistryDNSSuffix:   "azurecr.io",
 	}
 
 	// GermanCloud is the cloud environment operated in Germany
@@ -116,6 +120,7 @@ var (
 		ServiceBusEndpointSuffix:     "servicebus.cloudapi.de",
 		ServiceManagementVMDNSSuffix: "azurecloudapp.de",
 		ResourceManagerVMDNSSuffix:   "cloudapp.microsoftazure.de",
+		ContainerRegistryDNSSuffix:   "azurecr.io",
 	}
 )
 

vendor/github.com/Azure/go-autorest/autorest/client.go

@@ -8,6 +8,7 @@ import (
 	"log"
 	"net/http"
 	"net/http/cookiejar"
+	"runtime"
 	"time"
 )
 
@@ -22,13 +23,24 @@ const (
 	DefaultRetryAttempts = 3
 )
 
-var statusCodesForRetry = []int{
+var (
+	// defaultUserAgent builds a string containing the Go version, system archityecture and OS,
+	// and the go-autorest version.
+	defaultUserAgent = fmt.Sprintf("Go/%s (%s-%s) go-autorest/%s",
+		runtime.Version(),
+		runtime.GOARCH,
+		runtime.GOOS,
+		Version(),
+	)
+
+	statusCodesForRetry = []int{
 		http.StatusRequestTimeout,      // 408
 		http.StatusInternalServerError, // 500
 		http.StatusBadGateway,          // 502
 		http.StatusServiceUnavailable,  // 503
 		http.StatusGatewayTimeout,      // 504
-}
+	}
+)
 
 const (
 	requestFormat = `HTTP Request Begin ===================================================
@@ -140,13 +152,24 @@ type Client struct {
 // NewClientWithUserAgent returns an instance of a Client with the UserAgent set to the passed
 // string.
 func NewClientWithUserAgent(ua string) Client {
-	return Client{
+	c := Client{
 		PollingDelay:    DefaultPollingDelay,
 		PollingDuration: DefaultPollingDuration,
 		RetryAttempts:   DefaultRetryAttempts,
 		RetryDuration:   30 * time.Second,
-		UserAgent:       ua,
+		UserAgent:       defaultUserAgent,
 	}
+	c.AddToUserAgent(ua)
+	return c
+}
+
+// AddToUserAgent adds an extension to the current user agent
+func (c *Client) AddToUserAgent(extension string) error {
+	if extension != "" {
+		c.UserAgent = fmt.Sprintf("%s %s", c.UserAgent, extension)
+		return nil
+	}
+	return fmt.Errorf("Extension was empty, User Agent stayed as %s", c.UserAgent)
 }
 
 // Do implements the Sender interface by invoking the active Sender after applying authorization.

vendor/github.com/Azure/go-autorest/autorest/preparer.go

@@ -183,6 +183,16 @@ func WithBaseURL(baseURL string) PrepareDecorator {
 	}
 }
 
+// WithCustomBaseURL returns a PrepareDecorator that replaces brace-enclosed keys within the
+// request base URL (i.e., http.Request.URL) with the corresponding values from the passed map.
+func WithCustomBaseURL(baseURL string, urlParameters map[string]interface{}) PrepareDecorator {
+	parameters := ensureValueStrings(urlParameters)
+	for key, value := range parameters {
+		baseURL = strings.Replace(baseURL, "{"+key+"}", value, -1)
+	}
+	return WithBaseURL(baseURL)
+}
+
 // WithFormData returns a PrepareDecoratore that "URL encodes" (e.g., bar=baz&foo=quux) into the
 // http.Request body.
 func WithFormData(v url.Values) PrepareDecorator {

vendor/github.com/Azure/go-autorest/autorest/responder.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"encoding/xml"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"net/http"
 	"strings"
@@ -87,6 +88,24 @@ func ByCopying(b *bytes.Buffer) RespondDecorator {
 	}
 }
 
+// ByDiscardingBody returns a RespondDecorator that first invokes the passed Responder after which
+// it copies the remaining bytes (if any) in the response body to ioutil.Discard. Since the passed
+// Responder is invoked prior to discarding the response body, the decorator may occur anywhere
+// within the set.
+func ByDiscardingBody() RespondDecorator {
+	return func(r Responder) Responder {
+		return ResponderFunc(func(resp *http.Response) error {
+			err := r.Respond(resp)
+			if err == nil && resp != nil && resp.Body != nil {
+				if _, err := io.Copy(ioutil.Discard, resp.Body); err != nil {
+					return fmt.Errorf("Error discarding the response body: %v", err)
+				}
+			}
+			return err
+		})
+	}
+}
+
 // ByClosing returns a RespondDecorator that first invokes the passed Responder after which it
 // closes the response body. Since the passed Responder is invoked prior to closing the response
 // body, the decorator may occur anywhere within the set.
@@ -128,6 +147,8 @@ func ByUnmarshallingJSON(v interface{}) RespondDecorator {
 			err := r.Respond(resp)
 			if err == nil {
 				b, errInner := ioutil.ReadAll(resp.Body)
+				// Some responses might include a BOM, remove for successful unmarshalling
+				b = bytes.TrimPrefix(b, []byte("\xef\xbb\xbf"))
 				if errInner != nil {
 					err = fmt.Errorf("Error occurred reading http.Response#Body - Error = '%v'", errInner)
 				} else if len(strings.Trim(string(b), " ")) > 0 {

vendor/github.com/Azure/go-autorest/autorest/sender.go

@@ -73,7 +73,7 @@ func SendWithSender(s Sender, r *http.Request, decorators ...SendDecorator) (*ht
 func AfterDelay(d time.Duration) SendDecorator {
 	return func(s Sender) Sender {
 		return SenderFunc(func(r *http.Request) (*http.Response, error) {
-			if !DelayForBackoff(d, 1, r.Cancel) {
+			if !DelayForBackoff(d, 0, r.Cancel) {
 				return nil, fmt.Errorf("autorest: AfterDelay canceled before full delay")
 			}
 			return s.Do(r)
@@ -97,7 +97,7 @@ func DoCloseIfError() SendDecorator {
 		return SenderFunc(func(r *http.Request) (*http.Response, error) {
 			resp, err := s.Do(r)
 			if err != nil {
-				Respond(resp, ByClosing())
+				Respond(resp, ByDiscardingBody(), ByClosing())
 			}
 			return resp, err
 		})
@@ -156,6 +156,7 @@ func DoPollForStatusCodes(duration time.Duration, delay time.Duration, codes ...
 
 				for err == nil && ResponseHasStatusCode(resp, codes...) {
 					Respond(resp,
+						ByDiscardingBody(),
 						ByClosing())
 					resp, err = SendWithSender(s, r,
 						AfterDelay(GetRetryAfter(resp, delay)))
@@ -257,6 +258,8 @@ func WithLogging(logger *log.Logger) SendDecorator {
 // passed attempt (i.e., an exponential backoff delay). Backoff duration is in seconds and can set
 // to zero for no delay. The delay may be canceled by closing the passed channel. If terminated early,
 // returns false.
+// Note: Passing attempt 1 will result in doubling "backoff" duration. Treat this as a zero-based attempt
+// count.
 func DelayForBackoff(backoff time.Duration, attempt int, cancel <-chan struct{}) bool {
 	select {
 	case <-time.After(time.Duration(backoff.Seconds()*math.Pow(2, float64(attempt))) * time.Second):

vendor/github.com/Azure/go-autorest/autorest/validation/validation.go

@@ -1,373 +0,0 @@
-/*
-Package validation provides methods for validating parameter value using reflection.
-*/
-package validation
-
-import (
-	"fmt"
-	"reflect"
-	"regexp"
-	"strings"
-)
-
-// Constraint stores constraint name, target field name
-// Rule and chain validations.
-type Constraint struct {
-
-	// Target field name for validation.
-	Target string
-
-	// Constraint name e.g. minLength, MaxLength, Pattern, etc.
-	Name string
-
-	// Rule for constraint e.g. greater than 10, less than 5 etc.
-	Rule interface{}
-
-	// Chain Validations for struct type
-	Chain []Constraint
-}
-
-// Validation stores parameter-wise validation.
-type Validation struct {
-	TargetValue interface{}
-	Constraints []Constraint
-}
-
-// Constraint list
-const (
-	Empty            = "Empty"
-	Null             = "Null"
-	ReadOnly         = "ReadOnly"
-	Pattern          = "Pattern"
-	MaxLength        = "MaxLength"
-	MinLength        = "MinLength"
-	MaxItems         = "MaxItems"
-	MinItems         = "MinItems"
-	MultipleOf       = "MultipleOf"
-	UniqueItems      = "UniqueItems"
-	InclusiveMaximum = "InclusiveMaximum"
-	ExclusiveMaximum = "ExclusiveMaximum"
-	ExclusiveMinimum = "ExclusiveMinimum"
-	InclusiveMinimum = "InclusiveMinimum"
-)
-
-// Validate method validates constraints on parameter
-// passed in validation array.
-func Validate(m []Validation) error {
-	for _, item := range m {
-		v := reflect.ValueOf(item.TargetValue)
-		for _, constraint := range item.Constraints {
-			var err error
-			switch v.Kind() {
-			case reflect.Ptr:
-				err = validatePtr(v, constraint)
-			case reflect.String:
-				err = validateString(v, constraint)
-			case reflect.Struct:
-				err = validateStruct(v, constraint)
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				err = validateInt(v, constraint)
-			case reflect.Float32, reflect.Float64:
-				err = validateFloat(v, constraint)
-			case reflect.Array, reflect.Slice, reflect.Map:
-				err = validateArrayMap(v, constraint)
-			default:
-				err = createError(v, constraint, fmt.Sprintf("unknown type %v", v.Kind()))
-			}
-
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func validateStruct(x reflect.Value, v Constraint, name ...string) error {
-	//Get field name from target name which is in format a.b.c
-	s := strings.Split(v.Target, ".")
-	f := x.FieldByName(s[len(s)-1])
-	if isZero(f) {
-		return createError(x, v, fmt.Sprintf("field %q doesn't exist", v.Target))
-	}
-
-	if err := Validate([]Validation{
-		{
-			TargetValue: getInterfaceValue(f),
-			Constraints: []Constraint{v},
-		},
-	}); err != nil {
-		return err
-	}
-	return nil
-}
-
-func validatePtr(x reflect.Value, v Constraint) error {
-	if v.Name == ReadOnly {
-		if !x.IsNil() {
-			return createError(x.Elem(), v, "readonly parameter; must send as nil or empty in request")
-		}
-		return nil
-	}
-	if x.IsNil() {
-		return checkNil(x, v)
-	}
-	if v.Chain != nil {
-		return Validate([]Validation{
-			{
-				TargetValue: getInterfaceValue(x.Elem()),
-				Constraints: v.Chain,
-			},
-		})
-	}
-	return nil
-}
-
-func validateInt(x reflect.Value, v Constraint) error {
-	i := x.Int()
-	r, ok := v.Rule.(int)
-	if !ok {
-		return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.Name, v.Rule))
-	}
-	switch v.Name {
-	case MultipleOf:
-		if i%int64(r) != 0 {
-			return createError(x, v, fmt.Sprintf("value must be a multiple of %v", r))
-		}
-	case ExclusiveMinimum:
-		if i <= int64(r) {
-			return createError(x, v, fmt.Sprintf("value must be greater than %v", r))
-		}
-	case ExclusiveMaximum:
-		if i >= int64(r) {
-			return createError(x, v, fmt.Sprintf("value must be less than %v", r))
-		}
-	case InclusiveMinimum:
-		if i < int64(r) {
-			return createError(x, v, fmt.Sprintf("value must be greater than or equal to %v", r))
-		}
-	case InclusiveMaximum:
-		if i > int64(r) {
-			return createError(x, v, fmt.Sprintf("value must be less than or equal to %v", r))
-		}
-	default:
-		return createError(x, v, fmt.Sprintf("constraint %v is not applicable for type integer", v.Name))
-	}
-	return nil
-}
-
-func validateFloat(x reflect.Value, v Constraint) error {
-	f := x.Float()
-	r, ok := v.Rule.(float64)
-	if !ok {
-		return createError(x, v, fmt.Sprintf("rule must be float value for %v constraint; got: %v", v.Name, v.Rule))
-	}
-	switch v.Name {
-	case ExclusiveMinimum:
-		if f <= r {
-			return createError(x, v, fmt.Sprintf("value must be greater than %v", r))
-		}
-	case ExclusiveMaximum:
-		if f >= r {
-			return createError(x, v, fmt.Sprintf("value must be less than %v", r))
-		}
-	case InclusiveMinimum:
-		if f < r {
-			return createError(x, v, fmt.Sprintf("value must be greater than or equal to %v", r))
-		}
-	case InclusiveMaximum:
-		if f > r {
-			return createError(x, v, fmt.Sprintf("value must be less than or equal to %v", r))
-		}
-	default:
-		return createError(x, v, fmt.Sprintf("constraint %s is not applicable for type float", v.Name))
-	}
-	return nil
-}
-
-func validateString(x reflect.Value, v Constraint) error {
-	s := x.String()
-	switch v.Name {
-	case Empty:
-		if len(s) == 0 {
-			return checkEmpty(x, v)
-		}
-	case Pattern:
-		reg, err := regexp.Compile(v.Rule.(string))
-		if err != nil {
-			return createError(x, v, err.Error())
-		}
-		if !reg.MatchString(s) {
-			return createError(x, v, fmt.Sprintf("value doesn't match pattern %v", v.Rule))
-		}
-	case MaxLength:
-		if _, ok := v.Rule.(int); !ok {
-			return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.Name, v.Rule))
-		}
-		if len(s) > v.Rule.(int) {
-			return createError(x, v, fmt.Sprintf("value length must be less than %v", v.Rule))
-		}
-	case MinLength:
-		if _, ok := v.Rule.(int); !ok {
-			return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.Name, v.Rule))
-		}
-		if len(s) < v.Rule.(int) {
-			return createError(x, v, fmt.Sprintf("value length must be greater than %v", v.Rule))
-		}
-	case ReadOnly:
-		if len(s) > 0 {
-			return createError(reflect.ValueOf(s), v, "readonly parameter; must send as nil or empty in request")
-		}
-	default:
-		return createError(x, v, fmt.Sprintf("constraint %s is not applicable to string type", v.Name))
-	}
-
-	if v.Chain != nil {
-		return Validate([]Validation{
-			{
-				TargetValue: getInterfaceValue(x),
-				Constraints: v.Chain,
-			},
-		})
-	}
-	return nil
-}
-
-func validateArrayMap(x reflect.Value, v Constraint) error {
-	switch v.Name {
-	case Null:
-		if x.IsNil() {
-			return checkNil(x, v)
-		}
-	case Empty:
-		if x.IsNil() || x.Len() == 0 {
-			return checkEmpty(x, v)
-		}
-	case MaxItems:
-		if _, ok := v.Rule.(int); !ok {
-			return createError(x, v, fmt.Sprintf("rule must be integer for %v constraint; got: %v", v.Name, v.Rule))
-		}
-		if x.Len() > v.Rule.(int) {
-			return createError(x, v, fmt.Sprintf("maximum item limit is %v; got: %v", v.Rule, x.Len()))
-		}
-	case MinItems:
-		if _, ok := v.Rule.(int); !ok {
-			return createError(x, v, fmt.Sprintf("rule must be integer for %v constraint; got: %v", v.Name, v.Rule))
-		}
-		if x.Len() < v.Rule.(int) {
-			return createError(x, v, fmt.Sprintf("minimum item limit is %v; got: %v", v.Rule, x.Len()))
-		}
-	case UniqueItems:
-		if x.Kind() == reflect.Array || x.Kind() == reflect.Slice {
-			if !checkForUniqueInArray(x) {
-				return createError(x, v, fmt.Sprintf("all items in parameter %q must be unique; got:%v", v.Target, x))
-			}
-		} else if x.Kind() == reflect.Map {
-			if !checkForUniqueInMap(x) {
-				return createError(x, v, fmt.Sprintf("all items in parameter %q must be unique; got:%v", v.Target, x))
-			}
-		} else {
-			return createError(x, v, fmt.Sprintf("type must be array, slice or map for constraint %v; got: %v", v.Name, x.Kind()))
-		}
-	case ReadOnly:
-		if x.Len() != 0 {
-			return createError(x, v, "readonly parameter; must send as nil or empty in request")
-		}
-	default:
-		return createError(x, v, fmt.Sprintf("constraint %v is not applicable to array, slice and map type", v.Name))
-	}
-
-	if v.Chain != nil {
-		return Validate([]Validation{
-			{
-				TargetValue: getInterfaceValue(x),
-				Constraints: v.Chain,
-			},
-		})
-	}
-	return nil
-}
-
-func checkNil(x reflect.Value, v Constraint) error {
-	if _, ok := v.Rule.(bool); !ok {
-		return createError(x, v, fmt.Sprintf("rule must be bool value for %v constraint; got: %v", v.Name, v.Rule))
-	}
-	if v.Rule.(bool) {
-		return createError(x, v, "value can not be null; required parameter")
-	}
-	return nil
-}
-
-func checkEmpty(x reflect.Value, v Constraint) error {
-	if _, ok := v.Rule.(bool); !ok {
-		return createError(x, v, fmt.Sprintf("rule must be bool value for %v constraint; got: %v", v.Name, v.Rule))
-	}
-
-	if v.Rule.(bool) {
-		return createError(x, v, "value can not be null or empty; required parameter")
-	}
-	return nil
-}
-
-func checkForUniqueInArray(x reflect.Value) bool {
-	if x == reflect.Zero(reflect.TypeOf(x)) || x.Len() == 0 {
-		return false
-	}
-	arrOfInterface := make([]interface{}, x.Len())
-
-	for i := 0; i < x.Len(); i++ {
-		arrOfInterface[i] = x.Index(i).Interface()
-	}
-
-	m := make(map[interface{}]bool)
-	for _, val := range arrOfInterface {
-		if m[val] {
-			return false
-		}
-		m[val] = true
-	}
-	return true
-}
-
-func checkForUniqueInMap(x reflect.Value) bool {
-	if x == reflect.Zero(reflect.TypeOf(x)) || x.Len() == 0 {
-		return false
-	}
-	mapOfInterface := make(map[interface{}]interface{}, x.Len())
-
-	keys := x.MapKeys()
-	for _, k := range keys {
-		mapOfInterface[k.Interface()] = x.MapIndex(k).Interface()
-	}
-
-	m := make(map[interface{}]bool)
-	for _, val := range mapOfInterface {
-		if m[val] {
-			return false
-		}
-		m[val] = true
-	}
-	return true
-}
-
-func getInterfaceValue(x reflect.Value) interface{} {
-	if x.Kind() == reflect.Invalid {
-		return nil
-	}
-	return x.Interface()
-}
-
-func isZero(x interface{}) bool {
-	return x == reflect.Zero(reflect.TypeOf(x)).Interface()
-}
-
-func createError(x reflect.Value, v Constraint, err string) error {
-	return fmt.Errorf("autorest/validation: validation failed: parameter=%s constraint=%s value=%#v details: %s",
-		v.Target, v.Name, getInterfaceValue(x), err)
-}
-
-// NewErrorWithValidationError appends package type and method name in
-// validation error.
-func NewErrorWithValidationError(err error, packageType, method string) error {
-	return fmt.Errorf("%s#%s: Invalid input: %v", packageType, method, err)
-}

vendor/github.com/Azure/go-autorest/autorest/version.go

@@ -2,17 +2,28 @@ package autorest
 
 import (
 	"fmt"
+	"strings"
+	"sync"
 )
 
 const (
-	major        = "7"
+	major = 7
-	minor        = "0"
+	minor = 3
-	patch        = "0"
+	patch = 1
 	tag   = ""
-	semVerFormat = "%s.%s.%s%s"
 )
 
+var versionLock sync.Once
+var version string
+
 // Version returns the semantic version (see http://semver.org).
 func Version() string {
-	return fmt.Sprintf(semVerFormat, major, minor, patch, tag)
+	versionLock.Do(func() {
+		version = fmt.Sprintf("v%d.%d.%d", major, minor, patch)
+
+		if trimmed := strings.TrimPrefix(tag, "-"); trimmed != "" {
+			version = fmt.Sprintf("%s-%s", version, trimmed)
+		}
+	})
+	return version
 }

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

@@ -15,8 +15,8 @@ import (
 
 	"github.com/PuerkitoBio/urlesc"
 	"golang.org/x/net/idna"
+	"golang.org/x/text/secure/precis"
 	"golang.org/x/text/unicode/norm"
-	"golang.org/x/text/width"
 )
 
 // A set of normalization flags determines how a URL will
@@ -150,26 +150,22 @@ func MustNormalizeURLString(u string, f NormalizationFlags) string {
 // NormalizeURLString returns the normalized string, or an error if it can't be parsed into an URL object.
 // It takes an URL string as input, as well as the normalization flags.
 func NormalizeURLString(u string, f NormalizationFlags) (string, error) {
-	parsed, err := url.Parse(u)
+	if parsed, e := url.Parse(u); e != nil {
-	if err != nil {
+		return "", e
-		return "", err
+	} else {
-	}
+		options := make([]precis.Option, 1, 3)
-
+		options[0] = precis.IgnoreCase
 		if f&FlagLowercaseHost == FlagLowercaseHost {
-		parsed.Host = strings.ToLower(parsed.Host)
+			options = append(options, precis.FoldCase())
 		}
-
+		options = append(options, precis.Norm(norm.NFC))
-	// The idna package doesn't fully conform to RFC 5895
+		profile := precis.NewFreeform(options...)
-	// (https://tools.ietf.org/html/rfc5895), so we do it here.
+		if parsed.Host, e = idna.ToASCII(profile.NewTransformer().String(parsed.Host)); e != nil {
-	// Taken from Go 1.8 cycle source, courtesy of bradfitz.
+			return "", e
-	// TODO: Remove when (if?) idna package conforms to RFC 5895.
-	parsed.Host = width.Fold.String(parsed.Host)
-	parsed.Host = norm.NFC.String(parsed.Host)
-	if parsed.Host, err = idna.ToASCII(parsed.Host); err != nil {
-		return "", err
 		}
-
 		return NormalizeURL(parsed, f), nil
+	}
+	panic("Unreachable code.")
 }
 
 // NormalizeURL returns the normalized string.

vendor/github.com/blang/semver/range.go

@@ -1,233 +0,0 @@
-package semver
-
-import (
-	"fmt"
-	"strings"
-	"unicode"
-)
-
-type comparator func(Version, Version) bool
-
-var (
-	compEQ comparator = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) == 0
-	}
-	compNE = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) != 0
-	}
-	compGT = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) == 1
-	}
-	compGE = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) >= 0
-	}
-	compLT = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) == -1
-	}
-	compLE = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) <= 0
-	}
-)
-
-type versionRange struct {
-	v Version
-	c comparator
-}
-
-// rangeFunc creates a Range from the given versionRange.
-func (vr *versionRange) rangeFunc() Range {
-	return Range(func(v Version) bool {
-		return vr.c(v, vr.v)
-	})
-}
-
-// Range represents a range of versions.
-// A Range can be used to check if a Version satisfies it:
-//
-//     range, err := semver.ParseRange(">1.0.0 <2.0.0")
-//     range(semver.MustParse("1.1.1") // returns true
-type Range func(Version) bool
-
-// OR combines the existing Range with another Range using logical OR.
-func (rf Range) OR(f Range) Range {
-	return Range(func(v Version) bool {
-		return rf(v) || f(v)
-	})
-}
-
-// AND combines the existing Range with another Range using logical AND.
-func (rf Range) AND(f Range) Range {
-	return Range(func(v Version) bool {
-		return rf(v) && f(v)
-	})
-}
-
-// ParseRange parses a range and returns a Range.
-// If the range could not be parsed an error is returned.
-//
-// Valid ranges are:
-//   - "<1.0.0"
-//   - "<=1.0.0"
-//   - ">1.0.0"
-//   - ">=1.0.0"
-//   - "1.0.0", "=1.0.0", "==1.0.0"
-//   - "!1.0.0", "!=1.0.0"
-//
-// A Range can consist of multiple ranges separated by space:
-// Ranges can be linked by logical AND:
-//   - ">1.0.0 <2.0.0" would match between both ranges, so "1.1.1" and "1.8.7" but not "1.0.0" or "2.0.0"
-//   - ">1.0.0 <3.0.0 !2.0.3-beta.2" would match every version between 1.0.0 and 3.0.0 except 2.0.3-beta.2
-//
-// Ranges can also be linked by logical OR:
-//   - "<2.0.0 || >=3.0.0" would match "1.x.x" and "3.x.x" but not "2.x.x"
-//
-// AND has a higher precedence than OR. It's not possible to use brackets.
-//
-// Ranges can be combined by both AND and OR
-//
-//  - `>1.0.0 <2.0.0 || >3.0.0 !4.2.1` would match `1.2.3`, `1.9.9`, `3.1.1`, but not `4.2.1`, `2.1.1`
-func ParseRange(s string) (Range, error) {
-	parts := splitAndTrim(s)
-	orParts, err := splitORParts(parts)
-	if err != nil {
-		return nil, err
-	}
-	var orFn Range
-	for _, p := range orParts {
-		var andFn Range
-		for _, ap := range p {
-			opStr, vStr, err := splitComparatorVersion(ap)
-			if err != nil {
-				return nil, err
-			}
-			vr, err := buildVersionRange(opStr, vStr)
-			if err != nil {
-				return nil, fmt.Errorf("Could not parse Range %q: %s", ap, err)
-			}
-			rf := vr.rangeFunc()
-
-			// Set function
-			if andFn == nil {
-				andFn = rf
-			} else { // Combine with existing function
-				andFn = andFn.AND(rf)
-			}
-		}
-		if orFn == nil {
-			orFn = andFn
-		} else {
-			orFn = orFn.OR(andFn)
-		}
-
-	}
-	return orFn, nil
-}
-
-// splitORParts splits the already cleaned parts by '||'.
-// Checks for invalid positions of the operator and returns an
-// error if found.
-func splitORParts(parts []string) ([][]string, error) {
-	var ORparts [][]string
-	last := 0
-	for i, p := range parts {
-		if p == "||" {
-			if i == 0 {
-				return nil, fmt.Errorf("First element in range is '||'")
-			}
-			ORparts = append(ORparts, parts[last:i])
-			last = i + 1
-		}
-	}
-	if last == len(parts) {
-		return nil, fmt.Errorf("Last element in range is '||'")
-	}
-	ORparts = append(ORparts, parts[last:])
-	return ORparts, nil
-}
-
-// buildVersionRange takes a slice of 2: operator and version
-// and builds a versionRange, otherwise an error.
-func buildVersionRange(opStr, vStr string) (*versionRange, error) {
-	c := parseComparator(opStr)
-	if c == nil {
-		return nil, fmt.Errorf("Could not parse comparator %q in %q", opStr, strings.Join([]string{opStr, vStr}, ""))
-	}
-	v, err := Parse(vStr)
-	if err != nil {
-		return nil, fmt.Errorf("Could not parse version %q in %q: %s", vStr, strings.Join([]string{opStr, vStr}, ""), err)
-	}
-
-	return &versionRange{
-		v: v,
-		c: c,
-	}, nil
-
-}
-
-// splitAndTrim splits a range string by spaces and cleans leading and trailing spaces
-func splitAndTrim(s string) (result []string) {
-	last := 0
-	for i := 0; i < len(s); i++ {
-		if s[i] == ' ' {
-			if last < i-1 {
-				result = append(result, s[last:i])
-			}
-			last = i + 1
-		}
-	}
-	if last < len(s)-1 {
-		result = append(result, s[last:])
-	}
-	// parts := strings.Split(s, " ")
-	// for _, x := range parts {
-	// 	if s := strings.TrimSpace(x); len(s) != 0 {
-	// 		result = append(result, s)
-	// 	}
-	// }
-	return
-}
-
-// splitComparatorVersion splits the comparator from the version.
-// Spaces between the comparator and the version are not allowed.
-// Input must be free of leading or trailing spaces.
-func splitComparatorVersion(s string) (string, string, error) {
-	i := strings.IndexFunc(s, unicode.IsDigit)
-	if i == -1 {
-		return "", "", fmt.Errorf("Could not get version from string: %q", s)
-	}
-	return strings.TrimSpace(s[0:i]), s[i:], nil
-}
-
-func parseComparator(s string) comparator {
-	switch s {
-	case "==":
-		fallthrough
-	case "":
-		fallthrough
-	case "=":
-		return compEQ
-	case ">":
-		return compGT
-	case ">=":
-		return compGE
-	case "<":
-		return compLT
-	case "<=":
-		return compLE
-	case "!":
-		fallthrough
-	case "!=":
-		return compNE
-	}
-
-	return nil
-}
-
-// MustParseRange is like ParseRange but panics if the range cannot be parsed.
-func MustParseRange(s string) Range {
-	r, err := ParseRange(s)
-	if err != nil {
-		panic(`semver: ParseRange(` + s + `): ` + err.Error())
-	}
-	return r
-}

vendor/github.com/blang/semver/semver.go

@@ -200,29 +200,6 @@ func Make(s string) (Version, error) {
 	return Parse(s)
 }
 
-// ParseTolerant allows for certain version specifications that do not strictly adhere to semver
-// specs to be parsed by this library. It does so by normalizing versions before passing them to
-// Parse(). It currently trims spaces, removes a "v" prefix, and adds a 0 patch number to versions
-// with only major and minor components specified
-func ParseTolerant(s string) (Version, error) {
-	s = strings.TrimSpace(s)
-	s = strings.TrimPrefix(s, "v")
-
-	// Split into major.minor.(patch+pr+meta)
-	parts := strings.SplitN(s, ".", 3)
-	if len(parts) < 3 {
-		if strings.ContainsAny(parts[len(parts)-1], "+-") {
-			return Version{}, errors.New("Short version cannot contain PreRelease/Build meta data")
-		}
-		for len(parts) < 3 {
-			parts = append(parts, "0")
-		}
-		s = strings.Join(parts, ".")
-	}
-
-	return Parse(s)
-}
-
 // Parse parses version string and returns a validated Version or error
 func Parse(s string) (Version, error) {
 	if len(s) == 0 {

vendor/github.com/coreos/go-oidc/gen.go

@@ -1,150 +0,0 @@
-// +build ignore
-
-// This file is used to generate keys for tests.
-
-package main
-
-import (
-	"bytes"
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"text/template"
-
-	jose "gopkg.in/square/go-jose.v2"
-)
-
-type key struct {
-	name string
-	new  func() (crypto.Signer, error)
-}
-
-var keys = []key{
-	{
-		"ECDSA_256", func() (crypto.Signer, error) {
-			return ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-		},
-	},
-	{
-		"ECDSA_384", func() (crypto.Signer, error) {
-			return ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
-		},
-	},
-	{
-		"ECDSA_521", func() (crypto.Signer, error) {
-			return ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
-		},
-	},
-	{
-		"RSA_1024", func() (crypto.Signer, error) {
-			return rsa.GenerateKey(rand.Reader, 1024)
-		},
-	},
-	{
-		"RSA_2048", func() (crypto.Signer, error) {
-			return rsa.GenerateKey(rand.Reader, 2048)
-		},
-	},
-	{
-		"RSA_4096", func() (crypto.Signer, error) {
-			return rsa.GenerateKey(rand.Reader, 4096)
-		},
-	},
-}
-
-func newJWK(k key, prefix, ident string) (privBytes, pubBytes []byte, err error) {
-	priv, err := k.new()
-	if err != nil {
-		return nil, nil, fmt.Errorf("generate %s: %v", k.name, err)
-	}
-	pub := priv.Public()
-
-	privKey := &jose.JSONWebKey{Key: priv}
-	thumbprint, err := privKey.Thumbprint(crypto.SHA256)
-	if err != nil {
-		return nil, nil, fmt.Errorf("computing thumbprint: %v", err)
-	}
-
-	keyID := hex.EncodeToString(thumbprint)
-	privKey.KeyID = keyID
-	pubKey := &jose.JSONWebKey{Key: pub, KeyID: keyID}
-
-	privBytes, err = json.MarshalIndent(privKey, prefix, ident)
-	if err != nil {
-		return
-	}
-	pubBytes, err = json.MarshalIndent(pubKey, prefix, ident)
-	return
-}
-
-type keyData struct {
-	Name string
-	Priv string
-	Pub  string
-}
-
-var tmpl = template.Must(template.New("").Parse(`// +build !golint
-
-// This file contains statically created JWKs for tests created by gen.go
-
-package oidc
-
-import (
-	"encoding/json"
-
-	jose "gopkg.in/square/go-jose.v2"
-)
-
-func mustLoadJWK(s string) jose.JSONWebKey {
-	var jwk jose.JSONWebKey
-	if err := json.Unmarshal([]byte(s), &jwk); err != nil {
-		panic(err)
-	}
-	return jwk
-}
-
-var (
-{{- range $i, $key := .Keys }}
-	testKey{{ $key.Name }} = mustLoadJWK(` + "`" + `{{ $key.Pub }}` + "`" + `)
-	testKey{{ $key.Name }}_Priv = mustLoadJWK(` + "`" + `{{ $key.Priv }}` + "`" + `)
-{{ end -}}
-)
-`))
-
-func main() {
-	var tmplData struct {
-		Keys []keyData
-	}
-	for _, k := range keys {
-		for i := 0; i < 4; i++ {
-			log.Printf("generating %s", k.name)
-			priv, pub, err := newJWK(k, "\t", "\t")
-			if err != nil {
-				log.Fatal(err)
-			}
-			name := fmt.Sprintf("%s_%d", k.name, i)
-
-			tmplData.Keys = append(tmplData.Keys, keyData{
-				Name: name,
-				Priv: string(priv),
-				Pub:  string(pub),
-			})
-		}
-	}
-
-	buff := new(bytes.Buffer)
-	if err := tmpl.Execute(buff, tmplData); err != nil {
-		log.Fatalf("excuting template: %v", err)
-	}
-
-	if err := ioutil.WriteFile("jose_test.go", buff.Bytes(), 0644); err != nil {
-		log.Fatal(err)
-	}
-}

vendor/github.com/coreos/go-oidc/http/doc.go

@@ -1,2 +0,0 @@
-// Package http is DEPRECATED. Use net/http instead.
-package http

vendor/github.com/coreos/go-oidc/jose.go

@@ -1,20 +0,0 @@
-// +build !golint
-
-// Don't lint this file. We don't want to have to add a comment to each constant.
-
-package oidc
-
-const (
-	// JOSE asymmetric signing algorithm values as defined by RFC 7518
-	//
-	// see: https://tools.ietf.org/html/rfc7518#section-3.1
-	RS256 = "RS256" // RSASSA-PKCS-v1.5 using SHA-256
-	RS384 = "RS384" // RSASSA-PKCS-v1.5 using SHA-384
-	RS512 = "RS512" // RSASSA-PKCS-v1.5 using SHA-512
-	ES256 = "ES256" // ECDSA using P-256 and SHA-256
-	ES384 = "ES384" // ECDSA using P-384 and SHA-384
-	ES512 = "ES512" // ECDSA using P-521 and SHA-512
-	PS256 = "PS256" // RSASSA-PSS using SHA256 and MGF1-SHA256
-	PS384 = "PS384" // RSASSA-PSS using SHA384 and MGF1-SHA384
-	PS512 = "PS512" // RSASSA-PSS using SHA512 and MGF1-SHA512
-)

vendor/github.com/coreos/go-oidc/jose/doc.go

@@ -1,2 +0,0 @@
-// Package jose is DEPRECATED. Use gopkg.in/square/go-jose.v2 instead.
-package jose

vendor/github.com/coreos/go-oidc/jose/jwk.go

@@ -104,7 +104,7 @@ func encodeExponent(e int) string {
 			break
 		}
 	}
-	return base64.RawURLEncoding.EncodeToString(b[idx:])
+	return base64.URLEncoding.EncodeToString(b[idx:])
 }
 
 // Turns a URL encoded modulus of a key into a big int.
@@ -119,7 +119,7 @@ func decodeModulus(n string) (*big.Int, error) {
 }
 
 func encodeModulus(n *big.Int) string {
-	return base64.RawURLEncoding.EncodeToString(n.Bytes())
+	return base64.URLEncoding.EncodeToString(n.Bytes())
 }
 
 // decodeBase64URLPaddingOptional decodes Base64 whether there is padding or not.

vendor/github.com/coreos/go-oidc/jose/sig_hmac.go

@@ -0,0 +1,67 @@
+package jose
+
+import (
+	"bytes"
+	"crypto"
+	"crypto/hmac"
+	_ "crypto/sha256"
+	"errors"
+	"fmt"
+)
+
+type VerifierHMAC struct {
+	KeyID  string
+	Hash   crypto.Hash
+	Secret []byte
+}
+
+type SignerHMAC struct {
+	VerifierHMAC
+}
+
+func NewVerifierHMAC(jwk JWK) (*VerifierHMAC, error) {
+	if jwk.Alg != "" && jwk.Alg != "HS256" {
+		return nil, fmt.Errorf("unsupported key algorithm %q", jwk.Alg)
+	}
+
+	v := VerifierHMAC{
+		KeyID:  jwk.ID,
+		Secret: jwk.Secret,
+		Hash:   crypto.SHA256,
+	}
+
+	return &v, nil
+}
+
+func (v *VerifierHMAC) ID() string {
+	return v.KeyID
+}
+
+func (v *VerifierHMAC) Alg() string {
+	return "HS256"
+}
+
+func (v *VerifierHMAC) Verify(sig []byte, data []byte) error {
+	h := hmac.New(v.Hash.New, v.Secret)
+	h.Write(data)
+	if !bytes.Equal(sig, h.Sum(nil)) {
+		return errors.New("invalid hmac signature")
+	}
+	return nil
+}
+
+func NewSignerHMAC(kid string, secret []byte) *SignerHMAC {
+	return &SignerHMAC{
+		VerifierHMAC: VerifierHMAC{
+			KeyID:  kid,
+			Secret: secret,
+			Hash:   crypto.SHA256,
+		},
+	}
+}
+
+func (s *SignerHMAC) Sign(data []byte) ([]byte, error) {
+	h := hmac.New(s.Hash.New, s.Secret)
+	h.Write(data)
+	return h.Sum(nil), nil
+}

vendor/github.com/coreos/go-oidc/jwks.go

@@ -1,200 +0,0 @@
-package oidc
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/pquerna/cachecontrol"
-	"golang.org/x/net/context"
-	"golang.org/x/net/context/ctxhttp"
-	jose "gopkg.in/square/go-jose.v2"
-)
-
-// keysExpiryDelta is the allowed clock skew between a client and the OpenID Connect
-// server.
-//
-// When keys expire, they are valid for this amount of time after.
-//
-// If the keys have not expired, and an ID Token claims it was signed by a key not in
-// the cache, if and only if the keys expire in this amount of time, the keys will be
-// updated.
-const keysExpiryDelta = 30 * time.Second
-
-func newRemoteKeySet(ctx context.Context, jwksURL string, now func() time.Time) *remoteKeySet {
-	if now == nil {
-		now = time.Now
-	}
-	return &remoteKeySet{jwksURL: jwksURL, ctx: ctx, now: now}
-}
-
-type remoteKeySet struct {
-	jwksURL string
-	ctx     context.Context
-	now     func() time.Time
-
-	// guard all other fields
-	mu sync.Mutex
-
-	// inflightCtx suppresses parallel execution of updateKeys and allows
-	// multiple goroutines to wait for its result.
-	// Its Err() method returns any errors encountered during updateKeys.
-	//
-	// If nil, there is no inflight updateKeys request.
-	inflightCtx *inflight
-
-	// A set of cached keys and their expiry.
-	cachedKeys []jose.JSONWebKey
-	expiry     time.Time
-}
-
-// inflight is used to wait on some in-flight request from multiple goroutines
-type inflight struct {
-	done chan struct{}
-	err  error
-}
-
-// Done returns a channel that is closed when the inflight request finishes.
-func (i *inflight) Done() <-chan struct{} {
-	return i.done
-}
-
-// Err returns any error encountered during request execution. May be nil.
-func (i *inflight) Err() error {
-	return i.err
-}
-
-// Cancel signals completion of the inflight request with error err.
-// Must be called only once for particular inflight instance.
-func (i *inflight) Cancel(err error) {
-	i.err = err
-	close(i.done)
-}
-
-func (r *remoteKeySet) keysWithIDFromCache(keyIDs []string) ([]jose.JSONWebKey, bool) {
-	r.mu.Lock()
-	keys, expiry := r.cachedKeys, r.expiry
-	r.mu.Unlock()
-
-	// Have the keys expired?
-	if expiry.Add(keysExpiryDelta).Before(r.now()) {
-		return nil, false
-	}
-
-	var signingKeys []jose.JSONWebKey
-	for _, key := range keys {
-		if contains(keyIDs, key.KeyID) {
-			signingKeys = append(signingKeys, key)
-		}
-	}
-
-	if len(signingKeys) == 0 {
-		// Are the keys about to expire?
-		if r.now().Add(keysExpiryDelta).After(expiry) {
-			return nil, false
-		}
-	}
-
-	return signingKeys, true
-}
-func (r *remoteKeySet) keysWithID(ctx context.Context, keyIDs []string) ([]jose.JSONWebKey, error) {
-	keys, ok := r.keysWithIDFromCache(keyIDs)
-	if ok {
-		return keys, nil
-	}
-
-	var inflightCtx *inflight
-	func() {
-		r.mu.Lock()
-		defer r.mu.Unlock()
-
-		// If there's not a current inflight request, create one.
-		if r.inflightCtx == nil {
-			inflightCtx := &inflight{make(chan struct{}), nil}
-			r.inflightCtx = inflightCtx
-
-			go func() {
-				// TODO(ericchiang): Upstream Kubernetes request that we recover every time
-				// we spawn a goroutine, because panics in a goroutine will bring down the
-				// entire program. There's no way to recover from another goroutine's panic.
-				//
-				// Most users actually want to let the panic propagate and bring down the
-				// program because it implies some unrecoverable state.
-				//
-				// Add a context key to allow the recover behavior.
-				//
-				// See: https://github.com/coreos/go-oidc/issues/89
-
-				// Sync keys and close inflightCtx when that's done.
-				// Use the remoteKeySet's context instead of the requests context
-				// because a re-sync is unique to the keys set and will span multiple
-				// requests.
-				inflightCtx.Cancel(r.updateKeys(r.ctx))
-
-				r.mu.Lock()
-				defer r.mu.Unlock()
-				r.inflightCtx = nil
-			}()
-		}
-
-		inflightCtx = r.inflightCtx
-	}()
-
-	select {
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	case <-inflightCtx.Done():
-		if err := inflightCtx.Err(); err != nil {
-			return nil, err
-		}
-	}
-
-	// Since we've just updated keys, we don't care about the cache miss.
-	keys, _ = r.keysWithIDFromCache(keyIDs)
-	return keys, nil
-}
-
-func (r *remoteKeySet) updateKeys(ctx context.Context) error {
-	req, err := http.NewRequest("GET", r.jwksURL, nil)
-	if err != nil {
-		return fmt.Errorf("oidc: can't create request: %v", err)
-	}
-
-	resp, err := ctxhttp.Do(ctx, clientFromContext(ctx), req)
-	if err != nil {
-		return fmt.Errorf("oidc: get keys failed %v", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("oidc: read response body: %v", err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("oidc: get keys failed: %s %s", resp.Status, body)
-	}
-
-	var keySet jose.JSONWebKeySet
-	if err := json.Unmarshal(body, &keySet); err != nil {
-		return fmt.Errorf("oidc: failed to decode keys: %v %s", err, body)
-	}
-
-	// If the server doesn't provide cache control headers, assume the
-	// keys expire immediately.
-	expiry := r.now()
-
-	_, e, err := cachecontrol.CachableResponse(req, resp, cachecontrol.Options{})
-	if err == nil && e.After(expiry) {
-		expiry = e
-	}
-
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.cachedKeys = keySet.Keys
-	r.expiry = expiry
-
-	return nil
-}

vendor/github.com/coreos/go-oidc/key/doc.go

@@ -1,2 +0,0 @@
-// Package key is DEPRECATED. Use github.com/coreos/go-oidc instead.
-package key

vendor/github.com/coreos/go-oidc/oauth2/doc.go

@@ -1,2 +0,0 @@
-// Package oauth2 is DEPRECATED. Use golang.org/x/oauth instead.
-package oauth2

vendor/github.com/coreos/go-oidc/oidc.go

@@ -1,299 +0,0 @@
-// Package oidc implements OpenID Connect client logic for the golang.org/x/oauth2 package.
-package oidc
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"strings"
-	"time"
-
-	"golang.org/x/net/context"
-	"golang.org/x/net/context/ctxhttp"
-	"golang.org/x/oauth2"
-	jose "gopkg.in/square/go-jose.v2"
-)
-
-const (
-	// ScopeOpenID is the mandatory scope for all OpenID Connect OAuth2 requests.
-	ScopeOpenID = "openid"
-
-	// ScopeOfflineAccess is an optional scope defined by OpenID Connect for requesting
-	// OAuth2 refresh tokens.
-	//
-	// Support for this scope differs between OpenID Connect providers. For instance
-	// Google rejects it, favoring appending "access_type=offline" as part of the
-	// authorization request instead.
-	//
-	// See: https://openid.net/specs/openid-connect-core-1_0.html#OfflineAccess
-	ScopeOfflineAccess = "offline_access"
-)
-
-// ClientContext returns a new Context that carries the provided HTTP client.
-//
-// This method sets the same context key used by the golang.org/x/oauth2 package,
-// so the returned context works for that package too.
-//
-//    myClient := &http.Client{}
-//    ctx := oidc.ClientContext(parentContext, myClient)
-//
-//    // This will use the custom client
-//    provider, err := oidc.NewProvider(ctx, "https://accounts.example.com")
-//
-func ClientContext(ctx context.Context, client *http.Client) context.Context {
-	return context.WithValue(ctx, oauth2.HTTPClient, client)
-}
-
-func clientFromContext(ctx context.Context) *http.Client {
-	if client, ok := ctx.Value(oauth2.HTTPClient).(*http.Client); ok {
-		return client
-	}
-	return http.DefaultClient
-}
-
-// Provider represents an OpenID Connect server's configuration.
-type Provider struct {
-	issuer      string
-	authURL     string
-	tokenURL    string
-	userInfoURL string
-
-	// Raw claims returned by the server.
-	rawClaims []byte
-
-	remoteKeySet *remoteKeySet
-}
-
-type cachedKeys struct {
-	keys   []jose.JSONWebKey
-	expiry time.Time
-}
-
-type providerJSON struct {
-	Issuer      string `json:"issuer"`
-	AuthURL     string `json:"authorization_endpoint"`
-	TokenURL    string `json:"token_endpoint"`
-	JWKSURL     string `json:"jwks_uri"`
-	UserInfoURL string `json:"userinfo_endpoint"`
-}
-
-// NewProvider uses the OpenID Connect discovery mechanism to construct a Provider.
-//
-// The issuer is the URL identifier for the service. For example: "https://accounts.google.com"
-// or "https://login.salesforce.com".
-func NewProvider(ctx context.Context, issuer string) (*Provider, error) {
-	wellKnown := strings.TrimSuffix(issuer, "/") + "/.well-known/openid-configuration"
-	resp, err := ctxhttp.Get(ctx, clientFromContext(ctx), wellKnown)
-	if err != nil {
-		return nil, err
-	}
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("%s: %s", resp.Status, body)
-	}
-	defer resp.Body.Close()
-	var p providerJSON
-	if err := json.Unmarshal(body, &p); err != nil {
-		return nil, fmt.Errorf("oidc: failed to decode provider discovery object: %v", err)
-	}
-	if p.Issuer != issuer {
-		return nil, fmt.Errorf("oidc: issuer did not match the issuer returned by provider, expected %q got %q", issuer, p.Issuer)
-	}
-	return &Provider{
-		issuer:       p.Issuer,
-		authURL:      p.AuthURL,
-		tokenURL:     p.TokenURL,
-		userInfoURL:  p.UserInfoURL,
-		rawClaims:    body,
-		remoteKeySet: newRemoteKeySet(ctx, p.JWKSURL, time.Now),
-	}, nil
-}
-
-// Claims unmarshals raw fields returned by the server during discovery.
-//
-//    var claims struct {
-//        ScopesSupported []string `json:"scopes_supported"`
-//        ClaimsSupported []string `json:"claims_supported"`
-//    }
-//
-//    if err := provider.Claims(&claims); err != nil {
-//        // handle unmarshaling error
-//    }
-//
-// For a list of fields defined by the OpenID Connect spec see:
-// https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata
-func (p *Provider) Claims(v interface{}) error {
-	if p.rawClaims == nil {
-		return errors.New("oidc: claims not set")
-	}
-	return json.Unmarshal(p.rawClaims, v)
-}
-
-// Endpoint returns the OAuth2 auth and token endpoints for the given provider.
-func (p *Provider) Endpoint() oauth2.Endpoint {
-	return oauth2.Endpoint{AuthURL: p.authURL, TokenURL: p.tokenURL}
-}
-
-// UserInfo represents the OpenID Connect userinfo claims.
-type UserInfo struct {
-	Subject       string `json:"sub"`
-	Profile       string `json:"profile"`
-	Email         string `json:"email"`
-	EmailVerified bool   `json:"email_verified"`
-
-	claims []byte
-}
-
-// Claims unmarshals the raw JSON object claims into the provided object.
-func (u *UserInfo) Claims(v interface{}) error {
-	if u.claims == nil {
-		return errors.New("oidc: claims not set")
-	}
-	return json.Unmarshal(u.claims, v)
-}
-
-// UserInfo uses the token source to query the provider's user info endpoint.
-func (p *Provider) UserInfo(ctx context.Context, tokenSource oauth2.TokenSource) (*UserInfo, error) {
-	if p.userInfoURL == "" {
-		return nil, errors.New("oidc: user info endpoint is not supported by this provider")
-	}
-
-	req, err := http.NewRequest("GET", p.userInfoURL, nil)
-	if err != nil {
-		return nil, fmt.Errorf("oidc: create GET request: %v", err)
-	}
-
-	token, err := tokenSource.Token()
-	if err != nil {
-		return nil, fmt.Errorf("oidc: get access token: %v", err)
-	}
-	token.SetAuthHeader(req)
-
-	resp, err := ctxhttp.Do(ctx, clientFromContext(ctx), req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("%s: %s", resp.Status, body)
-	}
-
-	var userInfo UserInfo
-	if err := json.Unmarshal(body, &userInfo); err != nil {
-		return nil, fmt.Errorf("oidc: failed to decode userinfo: %v", err)
-	}
-	userInfo.claims = body
-	return &userInfo, nil
-}
-
-// IDToken is an OpenID Connect extension that provides a predictable representation
-// of an authorization event.
-//
-// The ID Token only holds fields OpenID Connect requires. To access additional
-// claims returned by the server, use the Claims method.
-type IDToken struct {
-	// The URL of the server which issued this token. This will always be the same
-	// as the URL used for initial discovery.
-	Issuer string
-
-	// The client, or set of clients, that this token is issued for.
-	Audience []string
-
-	// A unique string which identifies the end user.
-	Subject string
-
-	IssuedAt time.Time
-	Expiry   time.Time
-	Nonce    string
-
-	// Raw payload of the id_token.
-	claims []byte
-}
-
-// Claims unmarshals the raw JSON payload of the ID Token into a provided struct.
-//
-//		idToken, err := idTokenVerifier.Verify(rawIDToken)
-//		if err != nil {
-//			// handle error
-//		}
-//		var claims struct {
-//			Email         string `json:"email"`
-//			EmailVerified bool   `json:"email_verified"`
-//		}
-//		if err := idToken.Claims(&claims); err != nil {
-//			// handle error
-//		}
-//
-func (i *IDToken) Claims(v interface{}) error {
-	if i.claims == nil {
-		return errors.New("oidc: claims not set")
-	}
-	return json.Unmarshal(i.claims, v)
-}
-
-type idToken struct {
-	Issuer   string   `json:"iss"`
-	Subject  string   `json:"sub"`
-	Audience audience `json:"aud"`
-	Expiry   jsonTime `json:"exp"`
-	IssuedAt jsonTime `json:"iat"`
-	Nonce    string   `json:"nonce"`
-}
-
-type audience []string
-
-func (a *audience) UnmarshalJSON(b []byte) error {
-	var s string
-	if json.Unmarshal(b, &s) == nil {
-		*a = audience{s}
-		return nil
-	}
-	var auds []string
-	if err := json.Unmarshal(b, &auds); err != nil {
-		return err
-	}
-	*a = audience(auds)
-	return nil
-}
-
-func (a audience) MarshalJSON() ([]byte, error) {
-	if len(a) == 1 {
-		return json.Marshal(a[0])
-	}
-	return json.Marshal([]string(a))
-}
-
-type jsonTime time.Time
-
-func (j *jsonTime) UnmarshalJSON(b []byte) error {
-	var n json.Number
-	if err := json.Unmarshal(b, &n); err != nil {
-		return err
-	}
-	var unix int64
-
-	if t, err := n.Int64(); err == nil {
-		unix = t
-	} else {
-		f, err := n.Float64()
-		if err != nil {
-			return err
-		}
-		unix = int64(f)
-	}
-	*j = jsonTime(time.Unix(unix, 0))
-	return nil
-}
-
-func (j jsonTime) MarshalJSON() ([]byte, error) {
-	return json.Marshal(time.Time(j).Unix())
-}

vendor/github.com/coreos/go-oidc/oidc/doc.go

@@ -1,2 +0,0 @@
-// Package oidc is DEPRECATED. Use github.com/coreos/go-oidc instead.
-package oidc

vendor/github.com/coreos/go-oidc/oidc/provider.go

@@ -567,7 +567,7 @@ func (n *pcsStepNext) step(fn pcsStepFunc) (next pcsStepper) {
 		next = &pcsStepNext{aft: ttl}
 	} else {
 		next = &pcsStepRetry{aft: time.Second}
-		log.Printf("go-oidc: provider config sync failed, retrying in %v: %v", next.after(), err)
+		log.Printf("go-oidc: provider config sync falied, retyring in %v: %v", next.after(), err)
 	}
 	return
 }
@@ -586,7 +586,7 @@ func (r *pcsStepRetry) step(fn pcsStepFunc) (next pcsStepper) {
 		next = &pcsStepNext{aft: ttl}
 	} else {
 		next = &pcsStepRetry{aft: timeutil.ExpBackoff(r.aft, time.Minute)}
-		log.Printf("go-oidc: provider config sync failed, retrying in %v: %v", next.after(), err)
+		log.Printf("go-oidc: provider config sync falied, retyring in %v: %v", next.after(), err)
 	}
 	return
 }

vendor/github.com/coreos/go-oidc/verify.go

@@ -1,263 +0,0 @@
-package oidc
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
-
-	"golang.org/x/net/context"
-	"golang.org/x/oauth2"
-	jose "gopkg.in/square/go-jose.v2"
-)
-
-// IDTokenVerifier provides verification for ID Tokens.
-type IDTokenVerifier struct {
-	keySet *remoteKeySet
-	config *verificationConfig
-}
-
-// verificationConfig is the unexported configuration for an IDTokenVerifier.
-//
-// Users interact with this struct using a VerificationOption.
-type verificationConfig struct {
-	issuer string
-	// If provided, this value must be in the ID Token audiences.
-	audience string
-	// If not nil, check the expiry of the id token.
-	checkExpiry func() time.Time
-	// If specified, only these sets of algorithms may be used to sign the JWT.
-	requiredAlgs []string
-	// If not nil, don't verify nonce.
-	nonceSource NonceSource
-}
-
-// VerificationOption provides additional checks on ID Tokens.
-type VerificationOption interface {
-	// Unexport this method so other packages can't implement this interface.
-	updateConfig(c *verificationConfig)
-}
-
-// Verifier returns an IDTokenVerifier that uses the provider's key set to verify JWTs.
-//
-// The returned IDTokenVerifier is tied to the Provider's context and its behavior is
-// undefined once the Provider's context is canceled.
-func (p *Provider) Verifier(options ...VerificationOption) *IDTokenVerifier {
-	config := &verificationConfig{issuer: p.issuer}
-	for _, option := range options {
-		option.updateConfig(config)
-	}
-
-	return newVerifier(p.remoteKeySet, config)
-}
-
-func newVerifier(keySet *remoteKeySet, config *verificationConfig) *IDTokenVerifier {
-	// As discussed in the godocs for VerifrySigningAlg, because almost all providers
-	// only support RS256, default to only allowing it.
-	if len(config.requiredAlgs) == 0 {
-		config.requiredAlgs = []string{RS256}
-	}
-
-	return &IDTokenVerifier{
-		keySet: keySet,
-		config: config,
-	}
-}
-
-func parseJWT(p string) ([]byte, error) {
-	parts := strings.Split(p, ".")
-	if len(parts) < 2 {
-		return nil, fmt.Errorf("oidc: malformed jwt, expected 3 parts got %d", len(parts))
-	}
-	payload, err := base64.RawURLEncoding.DecodeString(parts[1])
-	if err != nil {
-		return nil, fmt.Errorf("oidc: malformed jwt payload: %v", err)
-	}
-	return payload, nil
-}
-
-func contains(sli []string, ele string) bool {
-	for _, s := range sli {
-		if s == ele {
-			return true
-		}
-	}
-	return false
-}
-
-// Verify parses a raw ID Token, verifies it's been signed by the provider, preforms
-// any additional checks passed as VerifictionOptions, and returns the payload.
-//
-// See: https://openid.net/specs/openid-connect-core-1_0.html#IDTokenValidation
-//
-//    oauth2Token, err := oauth2Config.Exchange(ctx, r.URL.Query().Get("code"))
-//    if err != nil {
-//        // handle error
-//    }
-//
-//    // Extract the ID Token from oauth2 token.
-//    rawIDToken, ok := oauth2Token.Extra("id_token").(string)
-//    if !ok {
-//        // handle error
-//    }
-//
-//    token, err := verifier.Verify(ctx, rawIDToken)
-//
-func (v *IDTokenVerifier) Verify(ctx context.Context, rawIDToken string) (*IDToken, error) {
-	jws, err := jose.ParseSigned(rawIDToken)
-	if err != nil {
-		return nil, fmt.Errorf("oidc: mallformed jwt: %v", err)
-	}
-
-	// Throw out tokens with invalid claims before trying to verify the token. This lets
-	// us do cheap checks before possibly re-syncing keys.
-	payload, err := parseJWT(rawIDToken)
-	if err != nil {
-		return nil, fmt.Errorf("oidc: malformed jwt: %v", err)
-	}
-	var token idToken
-	if err := json.Unmarshal(payload, &token); err != nil {
-		return nil, fmt.Errorf("oidc: failed to unmarshal claims: %v", err)
-	}
-
-	t := &IDToken{
-		Issuer:   token.Issuer,
-		Subject:  token.Subject,
-		Audience: []string(token.Audience),
-		Expiry:   time.Time(token.Expiry),
-		IssuedAt: time.Time(token.IssuedAt),
-		Nonce:    token.Nonce,
-		claims:   payload,
-	}
-
-	// Check issuer.
-	if t.Issuer != v.config.issuer {
-		return nil, fmt.Errorf("oidc: id token issued by a different provider, expected %q got %q", v.config.issuer, t.Issuer)
-	}
-
-	// If a client ID has been provided, make sure it's part of the audience.
-	if v.config.audience != "" {
-		if !contains(t.Audience, v.config.audience) {
-			return nil, fmt.Errorf("oidc: expected audience %q got %q", v.config.audience, t.Audience)
-		}
-	}
-
-	// If a set of required algorithms has been provided, ensure that the signatures use those.
-	var keyIDs, gotAlgs []string
-	for _, sig := range jws.Signatures {
-		if len(v.config.requiredAlgs) == 0 || contains(v.config.requiredAlgs, sig.Header.Algorithm) {
-			keyIDs = append(keyIDs, sig.Header.KeyID)
-		} else {
-			gotAlgs = append(gotAlgs, sig.Header.Algorithm)
-		}
-	}
-	if len(keyIDs) == 0 {
-		return nil, fmt.Errorf("oidc: no signatures use a require algorithm, expected %q got %q", v.config.requiredAlgs, gotAlgs)
-	}
-
-	// Get keys from the remote key set. This may trigger a re-sync.
-	keys, err := v.keySet.keysWithID(ctx, keyIDs)
-	if err != nil {
-		return nil, fmt.Errorf("oidc: get keys for id token: %v", err)
-	}
-	if len(keys) == 0 {
-		return nil, fmt.Errorf("oidc: no keys match signature ID(s) %q", keyIDs)
-	}
-
-	// Try to use a key to validate the signature.
-	var gotPayload []byte
-	for _, key := range keys {
-		if p, err := jws.Verify(&key); err == nil {
-			gotPayload = p
-		}
-	}
-	if len(gotPayload) == 0 {
-		return nil, fmt.Errorf("oidc: failed to verify id token")
-	}
-
-	// Ensure that the payload returned by the square actually matches the payload parsed earlier.
-	if !bytes.Equal(gotPayload, payload) {
-		return nil, errors.New("oidc: internal error, payload parsed did not match previous payload")
-	}
-
-	// Check the nonce after we've verified the token. We don't want to allow unverified
-	// payloads to trigger a nonce lookup.
-	if v.config.nonceSource != nil {
-		if err := v.config.nonceSource.ClaimNonce(t.Nonce); err != nil {
-			return nil, err
-		}
-	}
-
-	return t, nil
-}
-
-// VerifyAudience ensures that an ID Token was issued for the specific client.
-//
-// Note that a verified token may be valid for other clients, as OpenID Connect allows a token to have
-// multiple audiences.
-func VerifyAudience(clientID string) VerificationOption {
-	return clientVerifier{clientID}
-}
-
-type clientVerifier struct {
-	clientID string
-}
-
-func (v clientVerifier) updateConfig(c *verificationConfig) {
-	c.audience = v.clientID
-}
-
-// VerifyExpiry ensures that an ID Token has not expired.
-func VerifyExpiry() VerificationOption {
-	return expiryVerifier{}
-}
-
-type expiryVerifier struct{}
-
-func (v expiryVerifier) updateConfig(c *verificationConfig) {
-	c.checkExpiry = time.Now
-}
-
-// VerifySigningAlg enforces that an ID Token is signed by a specific signing algorithm.
-//
-// Because so many providers only support RS256, if this verifiction option isn't used,
-// the IDTokenVerifier defaults to only allowing RS256.
-func VerifySigningAlg(allowedAlgs ...string) VerificationOption {
-	return algVerifier{allowedAlgs}
-}
-
-type algVerifier struct {
-	algs []string
-}
-
-func (v algVerifier) updateConfig(c *verificationConfig) {
-	c.requiredAlgs = v.algs
-}
-
-// Nonce returns an auth code option which requires the ID Token created by the
-// OpenID Connect provider to contain the specified nonce.
-func Nonce(nonce string) oauth2.AuthCodeOption {
-	return oauth2.SetAuthURLParam("nonce", nonce)
-}
-
-// NonceSource represents a source which can verify a nonce is valid and has not
-// been claimed before.
-type NonceSource interface {
-	ClaimNonce(nonce string) error
-}
-
-// VerifyNonce ensures that the ID Token contains a nonce which can be claimed by the nonce source.
-func VerifyNonce(source NonceSource) VerificationOption {
-	return nonceVerifier{source}
-}
-
-type nonceVerifier struct {
-	nonceSource NonceSource
-}
-
-func (n nonceVerifier) updateConfig(c *verificationConfig) {
-	c.nonceSource = n.nonceSource
-}

vendor/github.com/coreos/pkg/capnslog/formatters.go

@@ -1,106 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package capnslog
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"runtime"
-	"strings"
-	"time"
-)
-
-type Formatter interface {
-	Format(pkg string, level LogLevel, depth int, entries ...interface{})
-	Flush()
-}
-
-func NewStringFormatter(w io.Writer) *StringFormatter {
-	return &StringFormatter{
-		w: bufio.NewWriter(w),
-	}
-}
-
-type StringFormatter struct {
-	w *bufio.Writer
-}
-
-func (s *StringFormatter) Format(pkg string, l LogLevel, i int, entries ...interface{}) {
-	now := time.Now().UTC()
-	s.w.WriteString(now.Format(time.RFC3339))
-	s.w.WriteByte(' ')
-	writeEntries(s.w, pkg, l, i, entries...)
-	s.Flush()
-}
-
-func writeEntries(w *bufio.Writer, pkg string, _ LogLevel, _ int, entries ...interface{}) {
-	if pkg != "" {
-		w.WriteString(pkg + ": ")
-	}
-	str := fmt.Sprint(entries...)
-	endsInNL := strings.HasSuffix(str, "\n")
-	w.WriteString(str)
-	if !endsInNL {
-		w.WriteString("\n")
-	}
-}
-
-func (s *StringFormatter) Flush() {
-	s.w.Flush()
-}
-
-func NewPrettyFormatter(w io.Writer, debug bool) Formatter {
-	return &PrettyFormatter{
-		w:     bufio.NewWriter(w),
-		debug: debug,
-	}
-}
-
-type PrettyFormatter struct {
-	w     *bufio.Writer
-	debug bool
-}
-
-func (c *PrettyFormatter) Format(pkg string, l LogLevel, depth int, entries ...interface{}) {
-	now := time.Now()
-	ts := now.Format("2006-01-02 15:04:05")
-	c.w.WriteString(ts)
-	ms := now.Nanosecond() / 1000
-	c.w.WriteString(fmt.Sprintf(".%06d", ms))
-	if c.debug {
-		_, file, line, ok := runtime.Caller(depth) // It's always the same number of frames to the user's call.
-		if !ok {
-			file = "???"
-			line = 1
-		} else {
-			slash := strings.LastIndex(file, "/")
-			if slash >= 0 {
-				file = file[slash+1:]
-			}
-		}
-		if line < 0 {
-			line = 0 // not a real line number
-		}
-		c.w.WriteString(fmt.Sprintf(" [%s:%d]", file, line))
-	}
-	c.w.WriteString(fmt.Sprint(" ", l.Char(), " | "))
-	writeEntries(c.w, pkg, l, depth, entries...)
-	c.Flush()
-}
-
-func (c *PrettyFormatter) Flush() {
-	c.w.Flush()
-}

vendor/github.com/coreos/pkg/capnslog/glog_formatter.go

@@ -1,96 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package capnslog
-
-import (
-	"bufio"
-	"bytes"
-	"io"
-	"os"
-	"runtime"
-	"strconv"
-	"strings"
-	"time"
-)
-
-var pid = os.Getpid()
-
-type GlogFormatter struct {
-	StringFormatter
-}
-
-func NewGlogFormatter(w io.Writer) *GlogFormatter {
-	g := &GlogFormatter{}
-	g.w = bufio.NewWriter(w)
-	return g
-}
-
-func (g GlogFormatter) Format(pkg string, level LogLevel, depth int, entries ...interface{}) {
-	g.w.Write(GlogHeader(level, depth+1))
-	g.StringFormatter.Format(pkg, level, depth+1, entries...)
-}
-
-func GlogHeader(level LogLevel, depth int) []byte {
-	// Lmmdd hh:mm:ss.uuuuuu threadid file:line]
-	now := time.Now().UTC()
-	_, file, line, ok := runtime.Caller(depth) // It's always the same number of frames to the user's call.
-	if !ok {
-		file = "???"
-		line = 1
-	} else {
-		slash := strings.LastIndex(file, "/")
-		if slash >= 0 {
-			file = file[slash+1:]
-		}
-	}
-	if line < 0 {
-		line = 0 // not a real line number
-	}
-	buf := &bytes.Buffer{}
-	buf.Grow(30)
-	_, month, day := now.Date()
-	hour, minute, second := now.Clock()
-	buf.WriteString(level.Char())
-	twoDigits(buf, int(month))
-	twoDigits(buf, day)
-	buf.WriteByte(' ')
-	twoDigits(buf, hour)
-	buf.WriteByte(':')
-	twoDigits(buf, minute)
-	buf.WriteByte(':')
-	twoDigits(buf, second)
-	buf.WriteByte('.')
-	buf.WriteString(strconv.Itoa(now.Nanosecond() / 1000))
-	buf.WriteByte('Z')
-	buf.WriteByte(' ')
-	buf.WriteString(strconv.Itoa(pid))
-	buf.WriteByte(' ')
-	buf.WriteString(file)
-	buf.WriteByte(':')
-	buf.WriteString(strconv.Itoa(line))
-	buf.WriteByte(']')
-	buf.WriteByte(' ')
-	return buf.Bytes()
-}
-
-const digits = "0123456789"
-
-func twoDigits(b *bytes.Buffer, d int) {
-	c2 := digits[d%10]
-	d /= 10
-	c1 := digits[d%10]
-	b.WriteByte(c1)
-	b.WriteByte(c2)
-}

vendor/github.com/coreos/pkg/capnslog/init.go

@@ -1,49 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// +build !windows
-
-package capnslog
-
-import (
-	"io"
-	"os"
-	"syscall"
-)
-
-// Here's where the opinionation comes in. We need some sensible defaults,
-// especially after taking over the log package. Your project (whatever it may
-// be) may see things differently. That's okay; there should be no defaults in
-// the main package that cannot be controlled or overridden programatically,
-// otherwise it's a bug. Doing so is creating your own init_log.go file much
-// like this one.
-
-func init() {
-	initHijack()
-
-	// Go `log` pacakge uses os.Stderr.
-	SetFormatter(NewDefaultFormatter(os.Stderr))
-	SetGlobalLogLevel(INFO)
-}
-
-func NewDefaultFormatter(out io.Writer) Formatter {
-	if syscall.Getppid() == 1 {
-		// We're running under init, which may be systemd.
-		f, err := NewJournaldFormatter()
-		if err == nil {
-			return f
-		}
-	}
-	return NewPrettyFormatter(out, false)
-}

vendor/github.com/coreos/pkg/capnslog/init_windows.go

@@ -1,25 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package capnslog
-
-import "os"
-
-func init() {
-	initHijack()
-
-	// Go `log` package uses os.Stderr.
-	SetFormatter(NewPrettyFormatter(os.Stderr, false))
-	SetGlobalLogLevel(INFO)
-}

vendor/github.com/coreos/pkg/capnslog/journald_formatter.go

@@ -1,68 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// +build !windows
-
-package capnslog
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/coreos/go-systemd/journal"
-)
-
-func NewJournaldFormatter() (Formatter, error) {
-	if !journal.Enabled() {
-		return nil, errors.New("No systemd detected")
-	}
-	return &journaldFormatter{}, nil
-}
-
-type journaldFormatter struct{}
-
-func (j *journaldFormatter) Format(pkg string, l LogLevel, _ int, entries ...interface{}) {
-	var pri journal.Priority
-	switch l {
-	case CRITICAL:
-		pri = journal.PriCrit
-	case ERROR:
-		pri = journal.PriErr
-	case WARNING:
-		pri = journal.PriWarning
-	case NOTICE:
-		pri = journal.PriNotice
-	case INFO:
-		pri = journal.PriInfo
-	case DEBUG:
-		pri = journal.PriDebug
-	case TRACE:
-		pri = journal.PriDebug
-	default:
-		panic("Unhandled loglevel")
-	}
-	msg := fmt.Sprint(entries...)
-	tags := map[string]string{
-		"PACKAGE":           pkg,
-		"SYSLOG_IDENTIFIER": filepath.Base(os.Args[0]),
-	}
-	err := journal.Send(msg, pri, tags)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-	}
-}
-
-func (j *journaldFormatter) Flush() {}

vendor/github.com/coreos/pkg/capnslog/log_hijack.go

@@ -1,39 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package capnslog
-
-import (
-	"log"
-)
-
-func initHijack() {
-	pkg := NewPackageLogger("log", "")
-	w := packageWriter{pkg}
-	log.SetFlags(0)
-	log.SetPrefix("")
-	log.SetOutput(w)
-}
-
-type packageWriter struct {
-	pl *PackageLogger
-}
-
-func (p packageWriter) Write(b []byte) (int, error) {
-	if p.pl.level < INFO {
-		return 0, nil
-	}
-	p.pl.internalLog(calldepth+2, INFO, string(b))
-	return len(b), nil
-}

vendor/github.com/coreos/pkg/capnslog/logmap.go

@@ -1,240 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package capnslog
-
-import (
-	"errors"
-	"strings"
-	"sync"
-)
-
-// LogLevel is the set of all log levels.
-type LogLevel int8
-
-const (
-	// CRITICAL is the lowest log level; only errors which will end the program will be propagated.
-	CRITICAL LogLevel = iota - 1
-	// ERROR is for errors that are not fatal but lead to troubling behavior.
-	ERROR
-	// WARNING is for errors which are not fatal and not errors, but are unusual. Often sourced from misconfigurations.
-	WARNING
-	// NOTICE is for normal but significant conditions.
-	NOTICE
-	// INFO is a log level for common, everyday log updates.
-	INFO
-	// DEBUG is the default hidden level for more verbose updates about internal processes.
-	DEBUG
-	// TRACE is for (potentially) call by call tracing of programs.
-	TRACE
-)
-
-// Char returns a single-character representation of the log level.
-func (l LogLevel) Char() string {
-	switch l {
-	case CRITICAL:
-		return "C"
-	case ERROR:
-		return "E"
-	case WARNING:
-		return "W"
-	case NOTICE:
-		return "N"
-	case INFO:
-		return "I"
-	case DEBUG:
-		return "D"
-	case TRACE:
-		return "T"
-	default:
-		panic("Unhandled loglevel")
-	}
-}
-
-// String returns a multi-character representation of the log level.
-func (l LogLevel) String() string {
-	switch l {
-	case CRITICAL:
-		return "CRITICAL"
-	case ERROR:
-		return "ERROR"
-	case WARNING:
-		return "WARNING"
-	case NOTICE:
-		return "NOTICE"
-	case INFO:
-		return "INFO"
-	case DEBUG:
-		return "DEBUG"
-	case TRACE:
-		return "TRACE"
-	default:
-		panic("Unhandled loglevel")
-	}
-}
-
-// Update using the given string value. Fulfills the flag.Value interface.
-func (l *LogLevel) Set(s string) error {
-	value, err := ParseLevel(s)
-	if err != nil {
-		return err
-	}
-
-	*l = value
-	return nil
-}
-
-// ParseLevel translates some potential loglevel strings into their corresponding levels.
-func ParseLevel(s string) (LogLevel, error) {
-	switch s {
-	case "CRITICAL", "C":
-		return CRITICAL, nil
-	case "ERROR", "0", "E":
-		return ERROR, nil
-	case "WARNING", "1", "W":
-		return WARNING, nil
-	case "NOTICE", "2", "N":
-		return NOTICE, nil
-	case "INFO", "3", "I":
-		return INFO, nil
-	case "DEBUG", "4", "D":
-		return DEBUG, nil
-	case "TRACE", "5", "T":
-		return TRACE, nil
-	}
-	return CRITICAL, errors.New("couldn't parse log level " + s)
-}
-
-type RepoLogger map[string]*PackageLogger
-
-type loggerStruct struct {
-	sync.Mutex
-	repoMap   map[string]RepoLogger
-	formatter Formatter
-}
-
-// logger is the global logger
-var logger = new(loggerStruct)
-
-// SetGlobalLogLevel sets the log level for all packages in all repositories
-// registered with capnslog.
-func SetGlobalLogLevel(l LogLevel) {
-	logger.Lock()
-	defer logger.Unlock()
-	for _, r := range logger.repoMap {
-		r.setRepoLogLevelInternal(l)
-	}
-}
-
-// GetRepoLogger may return the handle to the repository's set of packages' loggers.
-func GetRepoLogger(repo string) (RepoLogger, error) {
-	logger.Lock()
-	defer logger.Unlock()
-	r, ok := logger.repoMap[repo]
-	if !ok {
-		return nil, errors.New("no packages registered for repo " + repo)
-	}
-	return r, nil
-}
-
-// MustRepoLogger returns the handle to the repository's packages' loggers.
-func MustRepoLogger(repo string) RepoLogger {
-	r, err := GetRepoLogger(repo)
-	if err != nil {
-		panic(err)
-	}
-	return r
-}
-
-// SetRepoLogLevel sets the log level for all packages in the repository.
-func (r RepoLogger) SetRepoLogLevel(l LogLevel) {
-	logger.Lock()
-	defer logger.Unlock()
-	r.setRepoLogLevelInternal(l)
-}
-
-func (r RepoLogger) setRepoLogLevelInternal(l LogLevel) {
-	for _, v := range r {
-		v.level = l
-	}
-}
-
-// ParseLogLevelConfig parses a comma-separated string of "package=loglevel", in
-// order, and returns a map of the results, for use in SetLogLevel.
-func (r RepoLogger) ParseLogLevelConfig(conf string) (map[string]LogLevel, error) {
-	setlist := strings.Split(conf, ",")
-	out := make(map[string]LogLevel)
-	for _, setstring := range setlist {
-		setting := strings.Split(setstring, "=")
-		if len(setting) != 2 {
-			return nil, errors.New("oddly structured `pkg=level` option: " + setstring)
-		}
-		l, err := ParseLevel(setting[1])
-		if err != nil {
-			return nil, err
-		}
-		out[setting[0]] = l
-	}
-	return out, nil
-}
-
-// SetLogLevel takes a map of package names within a repository to their desired
-// loglevel, and sets the levels appropriately. Unknown packages are ignored.
-// "*" is a special package name that corresponds to all packages, and will be
-// processed first.
-func (r RepoLogger) SetLogLevel(m map[string]LogLevel) {
-	logger.Lock()
-	defer logger.Unlock()
-	if l, ok := m["*"]; ok {
-		r.setRepoLogLevelInternal(l)
-	}
-	for k, v := range m {
-		l, ok := r[k]
-		if !ok {
-			continue
-		}
-		l.level = v
-	}
-}
-
-// SetFormatter sets the formatting function for all logs.
-func SetFormatter(f Formatter) {
-	logger.Lock()
-	defer logger.Unlock()
-	logger.formatter = f
-}
-
-// NewPackageLogger creates a package logger object.
-// This should be defined as a global var in your package, referencing your repo.
-func NewPackageLogger(repo string, pkg string) (p *PackageLogger) {
-	logger.Lock()
-	defer logger.Unlock()
-	if logger.repoMap == nil {
-		logger.repoMap = make(map[string]RepoLogger)
-	}
-	r, rok := logger.repoMap[repo]
-	if !rok {
-		logger.repoMap[repo] = make(RepoLogger)
-		r = logger.repoMap[repo]
-	}
-	p, pok := r[pkg]
-	if !pok {
-		r[pkg] = &PackageLogger{
-			pkg:   pkg,
-			level: INFO,
-		}
-		p = r[pkg]
-	}
-	return
-}

vendor/github.com/coreos/pkg/capnslog/pkg_logger.go

@@ -1,158 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package capnslog
-
-import (
-	"fmt"
-	"os"
-)
-
-type PackageLogger struct {
-	pkg   string
-	level LogLevel
-}
-
-const calldepth = 2
-
-func (p *PackageLogger) internalLog(depth int, inLevel LogLevel, entries ...interface{}) {
-	if inLevel != CRITICAL && p.level < inLevel {
-		return
-	}
-	logger.Lock()
-	defer logger.Unlock()
-	if logger.formatter != nil {
-		logger.formatter.Format(p.pkg, inLevel, depth+1, entries...)
-	}
-}
-
-func (p *PackageLogger) LevelAt(l LogLevel) bool {
-	return p.level >= l
-}
-
-// Log a formatted string at any level between ERROR and TRACE
-func (p *PackageLogger) Logf(l LogLevel, format string, args ...interface{}) {
-	p.internalLog(calldepth, l, fmt.Sprintf(format, args...))
-}
-
-// Log a message at any level between ERROR and TRACE
-func (p *PackageLogger) Log(l LogLevel, args ...interface{}) {
-	p.internalLog(calldepth, l, fmt.Sprint(args...))
-}
-
-// log stdlib compatibility
-
-func (p *PackageLogger) Println(args ...interface{}) {
-	p.internalLog(calldepth, INFO, fmt.Sprintln(args...))
-}
-
-func (p *PackageLogger) Printf(format string, args ...interface{}) {
-	p.internalLog(calldepth, INFO, fmt.Sprintf(format, args...))
-}
-
-func (p *PackageLogger) Print(args ...interface{}) {
-	p.internalLog(calldepth, INFO, fmt.Sprint(args...))
-}
-
-// Panic and fatal
-
-func (p *PackageLogger) Panicf(format string, args ...interface{}) {
-	s := fmt.Sprintf(format, args...)
-	p.internalLog(calldepth, CRITICAL, s)
-	panic(s)
-}
-
-func (p *PackageLogger) Panic(args ...interface{}) {
-	s := fmt.Sprint(args...)
-	p.internalLog(calldepth, CRITICAL, s)
-	panic(s)
-}
-
-func (p *PackageLogger) Fatalf(format string, args ...interface{}) {
-	s := fmt.Sprintf(format, args...)
-	p.internalLog(calldepth, CRITICAL, s)
-	os.Exit(1)
-}
-
-func (p *PackageLogger) Fatal(args ...interface{}) {
-	s := fmt.Sprint(args...)
-	p.internalLog(calldepth, CRITICAL, s)
-	os.Exit(1)
-}
-
-// Error Functions
-
-func (p *PackageLogger) Errorf(format string, args ...interface{}) {
-	p.internalLog(calldepth, ERROR, fmt.Sprintf(format, args...))
-}
-
-func (p *PackageLogger) Error(entries ...interface{}) {
-	p.internalLog(calldepth, ERROR, entries...)
-}
-
-// Warning Functions
-
-func (p *PackageLogger) Warningf(format string, args ...interface{}) {
-	p.internalLog(calldepth, WARNING, fmt.Sprintf(format, args...))
-}
-
-func (p *PackageLogger) Warning(entries ...interface{}) {
-	p.internalLog(calldepth, WARNING, entries...)
-}
-
-// Notice Functions
-
-func (p *PackageLogger) Noticef(format string, args ...interface{}) {
-	p.internalLog(calldepth, NOTICE, fmt.Sprintf(format, args...))
-}
-
-func (p *PackageLogger) Notice(entries ...interface{}) {
-	p.internalLog(calldepth, NOTICE, entries...)
-}
-
-// Info Functions
-
-func (p *PackageLogger) Infof(format string, args ...interface{}) {
-	p.internalLog(calldepth, INFO, fmt.Sprintf(format, args...))
-}
-
-func (p *PackageLogger) Info(entries ...interface{}) {
-	p.internalLog(calldepth, INFO, entries...)
-}
-
-// Debug Functions
-
-func (p *PackageLogger) Debugf(format string, args ...interface{}) {
-	p.internalLog(calldepth, DEBUG, fmt.Sprintf(format, args...))
-}
-
-func (p *PackageLogger) Debug(entries ...interface{}) {
-	p.internalLog(calldepth, DEBUG, entries...)
-}
-
-// Trace Functions
-
-func (p *PackageLogger) Tracef(format string, args ...interface{}) {
-	p.internalLog(calldepth, TRACE, fmt.Sprintf(format, args...))
-}
-
-func (p *PackageLogger) Trace(entries ...interface{}) {
-	p.internalLog(calldepth, TRACE, entries...)
-}
-
-func (p *PackageLogger) Flush() {
-	logger.Lock()
-	defer logger.Unlock()
-	logger.formatter.Flush()
-}

vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go

@@ -1,65 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// +build !windows
-
-package capnslog
-
-import (
-	"fmt"
-	"log/syslog"
-)
-
-func NewSyslogFormatter(w *syslog.Writer) Formatter {
-	return &syslogFormatter{w}
-}
-
-func NewDefaultSyslogFormatter(tag string) (Formatter, error) {
-	w, err := syslog.New(syslog.LOG_DEBUG, tag)
-	if err != nil {
-		return nil, err
-	}
-	return NewSyslogFormatter(w), nil
-}
-
-type syslogFormatter struct {
-	w *syslog.Writer
-}
-
-func (s *syslogFormatter) Format(pkg string, l LogLevel, _ int, entries ...interface{}) {
-	for _, entry := range entries {
-		str := fmt.Sprint(entry)
-		switch l {
-		case CRITICAL:
-			s.w.Crit(str)
-		case ERROR:
-			s.w.Err(str)
-		case WARNING:
-			s.w.Warning(str)
-		case NOTICE:
-			s.w.Notice(str)
-		case INFO:
-			s.w.Info(str)
-		case DEBUG:
-			s.w.Debug(str)
-		case TRACE:
-			s.w.Debug(str)
-		default:
-			panic("Unhandled loglevel")
-		}
-	}
-}
-
-func (s *syslogFormatter) Flush() {
-}

vendor/github.com/dnsimple/dnsimple-go/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2017 Aetrion LLC dba DNSimple
+
+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.

vendor/github.com/dnsimple/dnsimple-go/dnsimple/accounts.go

@@ -0,0 +1,44 @@
+package dnsimple
+
+import (
+)
+
+type AccountsService struct {
+	client *Client
+}
+
+// Account represents a DNSimple account.
+type Account struct {
+	ID             int    `json:"id,omitempty"`
+	Email          string `json:"email,omitempty"`
+	PlanIdentifier string `json:"plan_identifier,omitempty"`
+	CreatedAt      string `json:"created_at,omitempty"`
+	UpdatedAt      string `json:"updated_at,omitempty"`
+}
+
+// accountsResponse represents a response from an API method that returns a collection of Account struct.
+type accountsResponse struct {
+	Response
+	Data []Account `json:"data"`
+}
+
+// ListAccounts list the accounts for an user.
+//
+// See https://developer.dnsimple.com/v2/accounts/#list
+func (s *AccountsService) ListAccounts(options *ListOptions) (*accountsResponse, error) {
+	path := versioned("/accounts")
+	accountsResponse := &accountsResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, accountsResponse)
+	if err != nil {
+		return accountsResponse, err
+	}
+
+	accountsResponse.HttpResponse = resp
+	return accountsResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/authentication.go

@@ -0,0 +1,68 @@
+package dnsimple
+
+import (
+	"encoding/base64"
+)
+
+const (
+	httpHeaderDomainToken   = "X-DNSimple-Domain-Token"
+	httpHeaderApiToken      = "X-DNSimple-Token"
+	httpHeaderAuthorization = "Authorization"
+)
+
+// Provides credentials that can be used for authenticating with DNSimple.
+//
+// See https://developer.dnsimple.com/v2/#authentication
+type Credentials interface {
+	// Returns the HTTP headers that should be set
+	// to authenticate the HTTP Request.
+	Headers() map[string]string
+}
+
+// Domain token authentication
+type domainTokenCredentials struct {
+	domainToken string
+}
+
+// NewDomainTokenCredentials construct Credentials using the DNSimple Domain Token method.
+func NewDomainTokenCredentials(domainToken string) Credentials {
+	return &domainTokenCredentials{domainToken: domainToken}
+}
+
+func (c *domainTokenCredentials) Headers() map[string]string {
+	return map[string]string{httpHeaderDomainToken: c.domainToken}
+}
+
+// HTTP basic authentication
+type httpBasicCredentials struct {
+	email    string
+	password string
+}
+
+// NewHTTPBasicCredentials construct Credentials using HTTP Basic Auth.
+func NewHTTPBasicCredentials(email, password string) Credentials {
+	return &httpBasicCredentials{email, password}
+}
+
+func (c *httpBasicCredentials) Headers() map[string]string {
+	return map[string]string{httpHeaderAuthorization: "Basic " + c.basicAuth(c.email, c.password)}
+}
+
+func (c *httpBasicCredentials) basicAuth(username, password string) string {
+	auth := username + ":" + password
+	return base64.StdEncoding.EncodeToString([]byte(auth))
+}
+
+// OAuth token authentication
+type oauthTokenCredentials struct {
+	oauthToken string
+}
+
+// NewOauthTokenCredentials construct Credentials using the OAuth access token.
+func NewOauthTokenCredentials(oauthToken string) Credentials {
+	return &oauthTokenCredentials{oauthToken: oauthToken}
+}
+
+func (c *oauthTokenCredentials) Headers() map[string]string {
+	return map[string]string{httpHeaderAuthorization: "Bearer " + c.oauthToken}
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/certificates.go

@@ -0,0 +1,134 @@
+package dnsimple
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// CertificatesService handles communication with the certificate related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/domains/certificates
+type CertificatesService struct {
+	client *Client
+}
+
+// Certificate represents a Certificate in DNSimple.
+type Certificate struct {
+	ID                  int    `json:"id,omitempty"`
+	DomainID            int    `json:"domain_id,omitempty"`
+	CommonName          string `json:"common_name,omitempty"`
+	Years               int    `json:"years,omitempty"`
+	State               string `json:"state,omitempty"`
+	AuthorityIdentifier string `json:"authority_identifier,omitempty"`
+	CreatedAt           string `json:"created_at,omitempty"`
+	UpdatedAt           string `json:"updated_at,omitempty"`
+	ExpiresOn           string `json:"expires_on,omitempty"`
+	CertificateRequest  string `json:"csr,omitempty"`
+}
+
+// CertificateBundle represents a container for all the PEM-encoded X509 certificate entities,
+// such as the private key, the server certificate and the intermediate chain.
+type CertificateBundle struct {
+	// CertificateRequest       string   `json:"csr,omitempty"`
+	PrivateKey               string   `json:"private_key,omitempty"`
+	ServerCertificate        string   `json:"server,omitempty"`
+	RootCertificate          string   `json:"root,omitempty"`
+	IntermediateCertificates []string `json:"chain,omitempty"`
+}
+
+func certificatePath(accountID, domainIdentifier, certificateID string) (path string) {
+	path = fmt.Sprintf("%v/certificates", domainPath(accountID, domainIdentifier))
+	if certificateID != "" {
+		path += fmt.Sprintf("/%v", certificateID)
+	}
+	return
+}
+
+// certificateResponse represents a response from an API method that returns a Certificate struct.
+type certificateResponse struct {
+	Response
+	Data *Certificate `json:"data"`
+}
+
+// certificateBundleResponse represents a response from an API method that returns a CertificatBundle struct.
+type certificateBundleResponse struct {
+	Response
+	Data *CertificateBundle `json:"data"`
+}
+
+// certificatesResponse represents a response from an API method that returns a collection of Certificate struct.
+type certificatesResponse struct {
+	Response
+	Data []Certificate `json:"data"`
+}
+
+// ListCertificates list the certificates for a domain.
+//
+// See https://developer.dnsimple.com/v2/domains/certificates#list
+func (s *CertificatesService) ListCertificates(accountID, domainIdentifier string, options *ListOptions) (*certificatesResponse, error) {
+	path := versioned(certificatePath(accountID, domainIdentifier, ""))
+	certificatesResponse := &certificatesResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, certificatesResponse)
+	if err != nil {
+		return certificatesResponse, err
+	}
+
+	certificatesResponse.HttpResponse = resp
+	return certificatesResponse, nil
+}
+
+// GetCertificate fetches the certificate.
+//
+// See https://developer.dnsimple.com/v2/domains/certificates#get
+func (s *CertificatesService) GetCertificate(accountID, domainIdentifier string, certificateID int) (*certificateResponse, error) {
+	path := versioned(certificatePath(accountID, domainIdentifier, strconv.Itoa(certificateID)))
+	certificateResponse := &certificateResponse{}
+
+	resp, err := s.client.get(path, certificateResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	certificateResponse.HttpResponse = resp
+	return certificateResponse, nil
+}
+
+// DownloadCertificate download the issued server certificate,
+// as well the root certificate and the intermediate chain.
+//
+// See https://developer.dnsimple.com/v2/domains/certificates#download
+func (s *CertificatesService) DownloadCertificate(accountID, domainIdentifier string, certificateID int) (*certificateBundleResponse, error) {
+	path := versioned(certificatePath(accountID, domainIdentifier, strconv.Itoa(certificateID)) + "/download")
+	certificateBundleResponse := &certificateBundleResponse{}
+
+	resp, err := s.client.get(path, certificateBundleResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	certificateBundleResponse.HttpResponse = resp
+	return certificateBundleResponse, nil
+}
+
+// GetCertificatePrivateKey fetches the certificate private key.
+//
+// See https://developer.dnsimple.com/v2/domains/certificates#get-private-key
+func (s *CertificatesService) GetCertificatePrivateKey(accountID, domainIdentifier string, certificateID int) (*certificateBundleResponse, error) {
+	path := versioned(certificatePath(accountID, domainIdentifier, strconv.Itoa(certificateID)) + "/private_key")
+	certificateBundleResponse := &certificateBundleResponse{}
+
+	resp, err := s.client.get(path, certificateBundleResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	certificateBundleResponse.HttpResponse = resp
+	return certificateBundleResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/contacts.go

@@ -0,0 +1,140 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// ContactsService handles communication with the contact related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/contacts/
+type ContactsService struct {
+	client *Client
+}
+
+// Contact represents a Contact in DNSimple.
+type Contact struct {
+	ID            int    `json:"id,omitempty"`
+	AccountID     int    `json:"account_id,omitempty"`
+	Label         string `json:"label,omitempty"`
+	FirstName     string `json:"first_name,omitempty"`
+	LastName      string `json:"last_name,omitempty"`
+	JobTitle      string `json:"job_title,omitempty"`
+	Organization  string `json:"organization_name,omitempty"`
+	Address1      string `json:"address1,omitempty"`
+	Address2      string `json:"address2,omitempty"`
+	City          string `json:"city,omitempty"`
+	StateProvince string `json:"state_province,omitempty"`
+	PostalCode    string `json:"postal_code,omitempty"`
+	Country       string `json:"country,omitempty"`
+	Phone         string `json:"phone,omitempty"`
+	Fax           string `json:"fax,omitempty"`
+	Email         string `json:"email,omitempty"`
+	CreatedAt     string `json:"created_at,omitempty"`
+	UpdatedAt     string `json:"updated_at,omitempty"`
+}
+
+func contactPath(accountID string, contactID int) (path string) {
+	path = fmt.Sprintf("/%v/contacts", accountID)
+	if contactID != 0 {
+		path += fmt.Sprintf("/%v", contactID)
+	}
+	return
+}
+
+// contactResponse represents a response from an API method that returns a Contact struct.
+type contactResponse struct {
+	Response
+	Data *Contact `json:"data"`
+}
+
+// contactsResponse represents a response from an API method that returns a collection of Contact struct.
+type contactsResponse struct {
+	Response
+	Data []Contact `json:"data"`
+}
+
+// ListContacts list the contacts for an account.
+//
+// See https://developer.dnsimple.com/v2/contacts/#list
+func (s *ContactsService) ListContacts(accountID string, options *ListOptions) (*contactsResponse, error) {
+	path := versioned(contactPath(accountID, 0))
+	contactsResponse := &contactsResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, contactsResponse)
+	if err != nil {
+		return contactsResponse, err
+	}
+
+	contactsResponse.HttpResponse = resp
+	return contactsResponse, nil
+}
+
+// CreateContact creates a new contact.
+//
+// See https://developer.dnsimple.com/v2/contacts/#create
+func (s *ContactsService) CreateContact(accountID string, contactAttributes Contact) (*contactResponse, error) {
+	path := versioned(contactPath(accountID, 0))
+	contactResponse := &contactResponse{}
+
+	resp, err := s.client.post(path, contactAttributes, contactResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	contactResponse.HttpResponse = resp
+	return contactResponse, nil
+}
+
+// GetContact fetches a contact.
+//
+// See https://developer.dnsimple.com/v2/contacts/#get
+func (s *ContactsService) GetContact(accountID string, contactID int) (*contactResponse, error) {
+	path := versioned(contactPath(accountID, contactID))
+	contactResponse := &contactResponse{}
+
+	resp, err := s.client.get(path, contactResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	contactResponse.HttpResponse = resp
+	return contactResponse, nil
+}
+
+// UpdateContact updates a contact.
+//
+// See https://developer.dnsimple.com/v2/contacts/#update
+func (s *ContactsService) UpdateContact(accountID string, contactID int, contactAttributes Contact) (*contactResponse, error) {
+	path := versioned(contactPath(accountID, contactID))
+	contactResponse := &contactResponse{}
+
+	resp, err := s.client.patch(path, contactAttributes, contactResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	contactResponse.HttpResponse = resp
+	return contactResponse, nil
+}
+
+// DeleteContact PERMANENTLY deletes a contact from the account.
+//
+// See https://developer.dnsimple.com/v2/contacts/#delete
+func (s *ContactsService) DeleteContact(accountID string, contactID int) (*contactResponse, error) {
+	path := versioned(contactPath(accountID, contactID))
+	contactResponse := &contactResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	contactResponse.HttpResponse = resp
+	return contactResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/dnsimple.go

@@ -0,0 +1,341 @@
+// Package dnsimple provides a client for the DNSimple API.
+// In order to use this package you will need a DNSimple account.
+package dnsimple
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/google/go-querystring/query"
+)
+
+const (
+	// Version identifies the current library version.
+	// This is a pro-forma convention given that Go dependencies
+	// tends to be fetched directly from the repo.
+	// It is also used in the user-agent identify the client.
+	Version = "0.14.0"
+
+	// defaultBaseURL to the DNSimple production API.
+	defaultBaseURL = "https://api.dnsimple.com"
+
+	// userAgent represents the default user agent used
+	// when no other user agent is set.
+	defaultUserAgent = "dnsimple-go/" + Version
+
+	apiVersion = "v2"
+)
+
+// Client represents a client to the DNSimple API.
+type Client struct {
+	// HttpClient is the underlying HTTP client
+	// used to communicate with the API.
+	HttpClient *http.Client
+
+	// Credentials used for accessing the DNSimple API
+	Credentials Credentials
+
+	// BaseURL for API requests.
+	// Defaults to the public DNSimple API, but can be set to a different endpoint (e.g. the sandbox).
+	BaseURL string
+
+	// UserAgent used when communicating with the DNSimple API.
+	UserAgent string
+
+	// Services used for talking to different parts of the DNSimple API.
+	Identity          *IdentityService
+	Accounts          *AccountsService
+	Certificates      *CertificatesService
+	Contacts          *ContactsService
+	Domains           *DomainsService
+	Oauth             *OauthService
+	Registrar         *RegistrarService
+	Services          *ServicesService
+	Templates         *TemplatesService
+	Tlds              *TldsService
+	VanityNameServers *VanityNameServersService
+	Webhooks          *WebhooksService
+	Zones             *ZonesService
+
+	// Set to true to output debugging logs during API calls
+	Debug bool
+}
+
+// ListOptions contains the common options you can pass to a List method
+// in order to control parameters such as paginations and page number.
+type ListOptions struct {
+	// The page to return
+	Page int `url:"page,omitempty"`
+
+	// The number of entries to return per page
+	PerPage int `url:"per_page,omitempty"`
+
+	// The order criteria to sort the results.
+	// The value is a comma-separated list of field[:direction],
+	// eg. name | name:desc | name:desc,expiration:desc
+	Sort string `url:"sort,omitempty"`
+}
+
+// NewClient returns a new DNSimple API client using the given credentials.
+func NewClient(credentials Credentials) *Client {
+	c := &Client{Credentials: credentials, HttpClient: &http.Client{}, BaseURL: defaultBaseURL}
+	c.Identity = &IdentityService{client: c}
+	c.Accounts = &AccountsService{client: c}
+	c.Certificates = &CertificatesService{client: c}
+	c.Contacts = &ContactsService{client: c}
+	c.Domains = &DomainsService{client: c}
+	c.Oauth = &OauthService{client: c}
+	c.Registrar = &RegistrarService{client: c}
+	c.Services = &ServicesService{client: c}
+	c.Templates = &TemplatesService{client: c}
+	c.Tlds = &TldsService{client: c}
+	c.VanityNameServers = &VanityNameServersService{client: c}
+	c.Webhooks = &WebhooksService{client: c}
+	c.Zones = &ZonesService{client: c}
+	return c
+}
+
+// NewRequest creates an API request.
+// The path is expected to be a relative path and will be resolved
+// according to the BaseURL of the Client. Paths should always be specified without a preceding slash.
+func (c *Client) NewRequest(method, path string, payload interface{}) (*http.Request, error) {
+	url := c.BaseURL + path
+
+	body := new(bytes.Buffer)
+	if payload != nil {
+		err := json.NewEncoder(body).Encode(payload)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	req, err := http.NewRequest(method, url, body)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Add("Accept", "application/json")
+	req.Header.Add("User-Agent", formatUserAgent(c.UserAgent))
+	for key, value := range c.Credentials.Headers() {
+		req.Header.Add(key, value)
+	}
+
+	return req, nil
+}
+
+// formatUserAgent builds the final user agent to use for HTTP requests.
+//
+// If no custom user agent is provided, the default user agent is used.
+//
+//     dnsimple-go/1.0
+//
+// If a custom user agent is provided, the final user agent is the combination of the custom user agent
+// prepended by the default user agent.
+//
+//     dnsimple-go/1.0 customAgentFlag
+//
+func formatUserAgent(customUserAgent string) string {
+	if customUserAgent == "" {
+		return defaultUserAgent
+	}
+
+	return fmt.Sprintf("%s %s", defaultUserAgent, customUserAgent)
+}
+
+func versioned(path string) string {
+	return fmt.Sprintf("/%s/%s", apiVersion, strings.Trim(path, "/"))
+}
+
+func (c *Client) get(path string, obj interface{}) (*http.Response, error) {
+	req, err := c.NewRequest("GET", path, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.Do(req, obj)
+}
+
+func (c *Client) post(path string, payload, obj interface{}) (*http.Response, error) {
+	req, err := c.NewRequest("POST", path, payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.Do(req, obj)
+}
+
+func (c *Client) put(path string, payload, obj interface{}) (*http.Response, error) {
+	req, err := c.NewRequest("PUT", path, payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.Do(req, obj)
+}
+
+func (c *Client) patch(path string, payload, obj interface{}) (*http.Response, error) {
+	req, err := c.NewRequest("PATCH", path, payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.Do(req, obj)
+}
+
+func (c *Client) delete(path string, payload interface{}, obj interface{}) (*http.Response, error) {
+	req, err := c.NewRequest("DELETE", path, payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.Do(req, obj)
+}
+
+// Do sends an API request and returns the API response.
+//
+// The API response is JSON decoded and stored in the value pointed by obj,
+// or returned as an error if an API error has occurred.
+// If obj implements the io.Writer interface, the raw response body will be written to obj,
+// without attempting to decode it.
+func (c *Client) Do(req *http.Request, obj interface{}) (*http.Response, error) {
+	if c.Debug {
+		log.Printf("Executing request (%v): %#v", req.URL, req)
+	}
+
+	resp, err := c.HttpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if c.Debug {
+		log.Printf("Response received: %#v", resp)
+	}
+
+	err = CheckResponse(resp)
+	if err != nil {
+		return resp, err
+	}
+
+	// If obj implements the io.Writer,
+	// the response body is decoded into v.
+	if obj != nil {
+		if w, ok := obj.(io.Writer); ok {
+			io.Copy(w, resp.Body)
+		} else {
+			err = json.NewDecoder(resp.Body).Decode(obj)
+		}
+	}
+
+	return resp, err
+}
+
+// A Response represents an API response.
+type Response struct {
+	// HTTP response
+	HttpResponse *http.Response
+
+	// If the response is paginated, the Pagination will store them.
+	Pagination *Pagination `json:"pagination"`
+}
+
+// RateLimit returns the maximum amount of requests this account can send in an hour.
+func (r *Response) RateLimit() int {
+	value, _ := strconv.Atoi(r.HttpResponse.Header.Get("X-RateLimit-Limit"))
+	return value
+}
+
+// RateLimitRemaining returns the remaining amount of requests this account can send within this hour window.
+func (r *Response) RateLimitRemaining() int {
+	value, _ := strconv.Atoi(r.HttpResponse.Header.Get("X-RateLimit-Remaining"))
+	return value
+}
+
+// RateLimitReset returns when the throttling window will be reset for this account.
+func (r *Response) RateLimitReset() time.Time {
+	value, _ := strconv.ParseInt(r.HttpResponse.Header.Get("X-RateLimit-Reset"), 10, 64)
+	return time.Unix(value, 0)
+}
+
+// If the response is paginated, Pagination represents the pagination information.
+type Pagination struct {
+	CurrentPage  int `json:"current_page"`
+	PerPage      int `json:"per_page"`
+	TotalPages   int `json:"total_pages"`
+	TotalEntries int `json:"total_entries"`
+}
+
+// An ErrorResponse represents an API response that generated an error.
+type ErrorResponse struct {
+	Response
+
+	// human-readable message
+	Message string `json:"message"`
+}
+
+// Error implements the error interface.
+func (r *ErrorResponse) Error() string {
+	return fmt.Sprintf("%v %v: %v %v",
+		r.HttpResponse.Request.Method, r.HttpResponse.Request.URL,
+		r.HttpResponse.StatusCode, r.Message)
+}
+
+// CheckResponse checks the API response for errors, and returns them if present.
+// A response is considered an error if the status code is different than 2xx. Specific requests
+// may have additional requirements, but this is sufficient in most of the cases.
+func CheckResponse(resp *http.Response) error {
+	if code := resp.StatusCode; 200 <= code && code <= 299 {
+		return nil
+	}
+
+	errorResponse := &ErrorResponse{}
+	errorResponse.HttpResponse = resp
+
+	err := json.NewDecoder(resp.Body).Decode(errorResponse)
+	if err != nil {
+		return err
+	}
+
+	return errorResponse
+}
+
+// addOptions adds the parameters in opt as URL query parameters to s.  opt
+// must be a struct whose fields may contain "url" tags.
+func addURLQueryOptions(path string, options interface{}) (string, error) {
+	opt := reflect.ValueOf(options)
+
+	// options is a pointer
+	// return if the value of the pointer is nil,
+	if opt.Kind() == reflect.Ptr && opt.IsNil() {
+		return path, nil
+	}
+
+	// append the options to the URL
+	u, err := url.Parse(path)
+	if err != nil {
+		return path, err
+	}
+
+	qs, err := query.Values(options)
+	if err != nil {
+		return path, err
+	}
+
+	uqs := u.Query()
+	for k, _ := range qs {
+		uqs.Set(k, qs.Get(k))
+	}
+	u.RawQuery = uqs.Encode()
+
+	return u.String(), nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/domains.go

@@ -0,0 +1,146 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// DomainsService handles communication with the domain related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/domains/
+type DomainsService struct {
+	client *Client
+}
+
+// Domain represents a domain in DNSimple.
+type Domain struct {
+	ID           int    `json:"id,omitempty"`
+	AccountID    int    `json:"account_id,omitempty"`
+	RegistrantID int    `json:"registrant_id,omitempty"`
+	Name         string `json:"name,omitempty"`
+	UnicodeName  string `json:"unicode_name,omitempty"`
+	Token        string `json:"token,omitempty"`
+	State        string `json:"state,omitempty"`
+	AutoRenew    bool   `json:"auto_renew,omitempty"`
+	PrivateWhois bool   `json:"private_whois,omitempty"`
+	ExpiresOn    string `json:"expires_on,omitempty"`
+	CreatedAt    string `json:"created_at,omitempty"`
+	UpdatedAt    string `json:"updated_at,omitempty"`
+}
+
+func domainPath(accountID string, domainIdentifier string) (path string) {
+	path = fmt.Sprintf("/%v/domains", accountID)
+	if domainIdentifier != "" {
+		path += fmt.Sprintf("/%v", domainIdentifier)
+	}
+	return
+}
+
+// domainResponse represents a response from an API method that returns a Domain struct.
+type domainResponse struct {
+	Response
+	Data *Domain `json:"data"`
+}
+
+// domainsResponse represents a response from an API method that returns a collection of Domain struct.
+type domainsResponse struct {
+	Response
+	Data []Domain `json:"data"`
+}
+
+// DomainListOptions specifies the optional parameters you can provide
+// to customize the DomainsService.ListDomains method.
+type DomainListOptions struct {
+	// Select domains where the name contains given string.
+	NameLike string `url:"name_like,omitempty"`
+
+	// Select domains where the registrant matches given ID.
+	RegistrantID int `url:"registrant_id,omitempty"`
+
+	ListOptions
+}
+
+// ListDomains lists the domains for an account.
+//
+// See https://developer.dnsimple.com/v2/domains/#list
+func (s *DomainsService) ListDomains(accountID string, options *DomainListOptions) (*domainsResponse, error) {
+	path := versioned(domainPath(accountID, ""))
+	domainsResponse := &domainsResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, domainsResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	domainsResponse.HttpResponse = resp
+	return domainsResponse, nil
+}
+
+// CreateDomain creates a new domain in the account.
+//
+// See https://developer.dnsimple.com/v2/domains/#create
+func (s *DomainsService) CreateDomain(accountID string, domainAttributes Domain) (*domainResponse, error) {
+	path := versioned(domainPath(accountID, ""))
+	domainResponse := &domainResponse{}
+
+	resp, err := s.client.post(path, domainAttributes, domainResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	domainResponse.HttpResponse = resp
+	return domainResponse, nil
+}
+
+// GetDomain fetches a domain.
+//
+// See https://developer.dnsimple.com/v2/domains/#get
+func (s *DomainsService) GetDomain(accountID string, domainIdentifier string) (*domainResponse, error) {
+	path := versioned(domainPath(accountID, domainIdentifier))
+	domainResponse := &domainResponse{}
+
+	resp, err := s.client.get(path, domainResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	domainResponse.HttpResponse = resp
+	return domainResponse, nil
+}
+
+// DeleteDomain PERMANENTLY deletes a domain from the account.
+//
+// See https://developer.dnsimple.com/v2/domains/#delete
+func (s *DomainsService) DeleteDomain(accountID string, domainIdentifier string) (*domainResponse, error) {
+	path := versioned(domainPath(accountID, domainIdentifier))
+	domainResponse := &domainResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	domainResponse.HttpResponse = resp
+	return domainResponse, nil
+}
+
+// ResetDomainToken resets the domain token.
+//
+// See https://developer.dnsimple.com/v2/domains/#reset-token
+func (s *DomainsService) ResetDomainToken(accountID string, domainIdentifier string) (*domainResponse, error) {
+	path := versioned(domainPath(accountID, domainIdentifier) + "/token")
+	domainResponse := &domainResponse{}
+
+	resp, err := s.client.post(path, nil, domainResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	domainResponse.HttpResponse = resp
+	return domainResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/domains_collaborators.go

@@ -0,0 +1,96 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// Collaborator represents a Collaborator in DNSimple.
+type Collaborator struct {
+	ID         int    `json:"id,omitempty"`
+	DomainID   int    `json:"domain_id,omitempty"`
+	DomainName string `json:"domain_name,omitempty"`
+	UserID     int    `json:"user_id,omitempty"`
+	UserEmail  string `json:"user_email,omitempty"`
+	Invitation bool   `json:"invitation,omitempty"`
+	CreatedAt  string `json:"created_at,omitempty"`
+	UpdatedAt  string `json:"updated_at,omitempty"`
+	AcceptedAt string `json:"accepted_at,omitempty"`
+}
+
+func collaboratorPath(accountID, domainIdentifier, collaboratorID string) (path string) {
+	path = fmt.Sprintf("%v/collaborators", domainPath(accountID, domainIdentifier))
+	if collaboratorID != "" {
+		path += fmt.Sprintf("/%v", collaboratorID)
+	}
+	return
+}
+
+// CollaboratorAttributes represents Collaborator attributes for AddCollaborator operation.
+type CollaboratorAttributes struct {
+	Email string `json:"email,omitempty"`
+}
+
+// collaboratorResponse represents a response from an API method that returns a Collaborator struct.
+type collaboratorResponse struct {
+	Response
+	Data *Collaborator `json:"data"`
+}
+
+// collaboratorsResponse represents a response from an API method that returns a collection of Collaborator struct.
+type collaboratorsResponse struct {
+	Response
+	Data []Collaborator `json:"data"`
+}
+
+// ListCollaborators list the collaborators for a domain.
+//
+// See https://developer.dnsimple.com/v2/domains/collaborators#list
+func (s *DomainsService) ListCollaborators(accountID, domainIdentifier string, options *ListOptions) (*collaboratorsResponse, error) {
+	path := versioned(collaboratorPath(accountID, domainIdentifier, ""))
+	collaboratorsResponse := &collaboratorsResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, collaboratorsResponse)
+	if err != nil {
+		return collaboratorsResponse, err
+	}
+
+	collaboratorsResponse.HttpResponse = resp
+	return collaboratorsResponse, nil
+}
+
+// AddCollaborator adds a new collaborator to the domain in the account.
+//
+// See https://developer.dnsimple.com/v2/domains/collaborators#add
+func (s *DomainsService) AddCollaborator(accountID string, domainIdentifier string, attributes CollaboratorAttributes) (*collaboratorResponse, error) {
+	path := versioned(collaboratorPath(accountID, domainIdentifier, ""))
+	collaboratorResponse := &collaboratorResponse{}
+
+	resp, err := s.client.post(path, attributes, collaboratorResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	collaboratorResponse.HttpResponse = resp
+	return collaboratorResponse, nil
+}
+
+// RemoveCollaborator PERMANENTLY deletes a domain from the account.
+//
+// See https://developer.dnsimple.com/v2/domains/collaborators#add
+func (s *DomainsService) RemoveCollaborator(accountID string, domainIdentifier string, collaboratorID string) (*collaboratorResponse, error) {
+	path := versioned(collaboratorPath(accountID, domainIdentifier, collaboratorID))
+	collaboratorResponse := &collaboratorResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	collaboratorResponse.HttpResponse = resp
+	return collaboratorResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/domains_delegation_signer_records.go

@@ -0,0 +1,105 @@
+package dnsimple
+
+import "fmt"
+
+// DelegationSignerRecord represents a delegation signer record for a domain in DNSimple.
+type DelegationSignerRecord struct {
+	ID         int    `json:"id,omitempty"`
+	DomainID   int    `json:"domain_id,omitempty"`
+	Algorithm  string `json:"algorithm"`
+	Digest     string `json:"digest"`
+	DigestType string `json:"digest_type"`
+	Keytag     string `json:"keytag"`
+	CreatedAt  string `json:"created_at,omitempty"`
+	UpdatedAt  string `json:"updated_at,omitempty"`
+}
+
+func delegationSignerRecordPath(accountID string, domainIdentifier string, dsRecordID int) (path string) {
+	path = fmt.Sprintf("%v/ds_records", domainPath(accountID, domainIdentifier))
+	if dsRecordID != 0 {
+		path += fmt.Sprintf("/%d", dsRecordID)
+	}
+	return
+}
+
+// delegationSignerRecordResponse represents a response from an API method that returns a DelegationSignerRecord struct.
+type delegationSignerRecordResponse struct {
+	Response
+	Data *DelegationSignerRecord `json:"data"`
+}
+
+// delegationSignerRecordResponse represents a response from an API method that returns a DelegationSignerRecord struct.
+type delegationSignerRecordsResponse struct {
+	Response
+	Data []DelegationSignerRecord `json:"data"`
+}
+
+// ListDelegationSignerRecords lists the delegation signer records for a domain.
+//
+// See https://developer.dnsimple.com/v2/domains/dnssec/#ds-record-list
+func (s *DomainsService) ListDelegationSignerRecords(accountID string, domainIdentifier string, options *ListOptions) (*delegationSignerRecordsResponse, error) {
+	path := versioned(delegationSignerRecordPath(accountID, domainIdentifier, 0))
+	dsRecordsResponse := &delegationSignerRecordsResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, dsRecordsResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	dsRecordsResponse.HttpResponse = resp
+	return dsRecordsResponse, nil
+}
+
+// CreateDelegationSignerRecord creates a new delegation signer record.
+//
+// See https://developer.dnsimple.com/v2/domains/dnssec/#ds-record-create
+func (s *DomainsService) CreateDelegationSignerRecord(accountID string, domainIdentifier string, dsRecordAttributes DelegationSignerRecord) (*delegationSignerRecordResponse, error) {
+	path := versioned(delegationSignerRecordPath(accountID, domainIdentifier, 0))
+	dsRecordResponse := &delegationSignerRecordResponse{}
+
+	resp, err := s.client.post(path, dsRecordAttributes, dsRecordResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	dsRecordResponse.HttpResponse = resp
+	return dsRecordResponse, nil
+}
+
+// GetDelegationSignerRecord fetches a delegation signer record.
+//
+// See https://developer.dnsimple.com/v2/domains/dnssec/#ds-record-get
+func (s *DomainsService) GetDelegationSignerRecord(accountID string, domainIdentifier string, dsRecordID int) (*delegationSignerRecordResponse, error) {
+	path := versioned(delegationSignerRecordPath(accountID, domainIdentifier, dsRecordID))
+	dsRecordResponse := &delegationSignerRecordResponse{}
+
+	resp, err := s.client.get(path, dsRecordResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	dsRecordResponse.HttpResponse = resp
+	return dsRecordResponse, nil
+}
+
+// DeleteDelegationSignerRecord PERMANENTLY deletes a delegation signer record
+// from the domain.
+//
+// See https://developer.dnsimple.com/v2/domains/dnssec/#ds-record-delete
+func (s *DomainsService) DeleteDelegationSignerRecord(accountID string, domainIdentifier string, dsRecordID int) (*delegationSignerRecordResponse, error) {
+	path := versioned(delegationSignerRecordPath(accountID, domainIdentifier, dsRecordID))
+	dsRecordResponse := &delegationSignerRecordResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	dsRecordResponse.HttpResponse = resp
+	return dsRecordResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/domains_dnssec.go

@@ -0,0 +1,68 @@
+package dnsimple
+
+import "fmt"
+
+// Dnssec represents the current DNSSEC settings for a domain in DNSimple.
+type Dnssec struct {
+	Enabled bool `json:"enabled"`
+}
+
+func dnssecPath(accountID string, domainIdentifier string) (path string) {
+	path = fmt.Sprintf("%v/dnssec", domainPath(accountID, domainIdentifier))
+	return
+}
+
+// dnssecResponse represents a response from an API method that returns a Dnssec struct.
+type dnssecResponse struct {
+	Response
+	Data *Dnssec `json:"data"`
+}
+
+// EnableDnssec enables DNSSEC on the domain.
+//
+// See https://developer.dnsimple.com/v2/domains/dnssec/#enable
+
+func (s *DomainsService) EnableDnssec(accountID string, domainIdentifier string) (*dnssecResponse, error) {
+	path := versioned(dnssecPath(accountID, domainIdentifier))
+	dnssecResponse := &dnssecResponse{}
+
+	resp, err := s.client.post(path, dnssecResponse, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	dnssecResponse.HttpResponse = resp
+	return dnssecResponse, nil
+}
+
+// DisableDnssec disables DNSSEC on the domain.
+//
+// See https://developer.dnsimple.com/v2/domains/dnssec/#disable
+func (s *DomainsService) DisableDnssec(accountID string, domainIdentifier string) (*dnssecResponse, error) {
+	path := versioned(dnssecPath(accountID, domainIdentifier))
+	dnssecResponse := &dnssecResponse{}
+
+	resp, err := s.client.delete(path, dnssecResponse, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	dnssecResponse.HttpResponse = resp
+	return dnssecResponse, nil
+}
+
+// GetDnssec retrieves the current status of DNSSEC on the domain.
+//
+// See https://developer.dnsimple.com/v2/domains/dnssec/#get
+func (s *DomainsService) GetDnssec(accountID string, domainIdentifier string) (*dnssecResponse, error) {
+	path := versioned(dnssecPath(accountID, domainIdentifier))
+	dnssecResponse := &dnssecResponse{}
+
+	resp, err := s.client.get(path, dnssecResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	dnssecResponse.HttpResponse = resp
+	return dnssecResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/domains_email_forwards.go

@@ -0,0 +1,104 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// EmailForward represents an email forward in DNSimple.
+type EmailForward struct {
+	ID        int    `json:"id,omitempty"`
+	DomainID  int    `json:"domain_id,omitempty"`
+	From      string `json:"from,omitempty"`
+	To        string `json:"to,omitempty"`
+	CreatedAt string `json:"created_at,omitempty"`
+	UpdatedAt string `json:"updated_at,omitempty"`
+}
+
+func emailForwardPath(accountID string, domainIdentifier string, forwardID int) (path string) {
+	path = fmt.Sprintf("%v/email_forwards", domainPath(accountID, domainIdentifier))
+	if forwardID != 0 {
+		path += fmt.Sprintf("/%d", forwardID)
+	}
+	return
+}
+
+// emailForwardResponse represents a response from an API method that returns an EmailForward struct.
+type emailForwardResponse struct {
+	Response
+	Data *EmailForward `json:"data"`
+}
+
+// emailForwardsResponse represents a response from an API method that returns a collection of EmailForward struct.
+type emailForwardsResponse struct {
+	Response
+	Data []EmailForward `json:"data"`
+}
+
+// ListEmailForwards lists the email forwards for a domain.
+//
+// See https://developer.dnsimple.com/v2/domains/email-forwards/#list
+func (s *DomainsService) ListEmailForwards(accountID string, domainIdentifier string, options *ListOptions) (*emailForwardsResponse, error) {
+	path := versioned(emailForwardPath(accountID, domainIdentifier , 0))
+	forwardsResponse := &emailForwardsResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, forwardsResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	forwardsResponse.HttpResponse = resp
+	return forwardsResponse, nil
+}
+
+// CreateEmailForward creates a new email forward.
+//
+// See https://developer.dnsimple.com/v2/domains/email-forwards/#create
+func (s *DomainsService) CreateEmailForward(accountID string, domainIdentifier string, forwardAttributes EmailForward) (*emailForwardResponse, error) {
+	path := versioned(emailForwardPath(accountID, domainIdentifier, 0))
+	forwardResponse := &emailForwardResponse{}
+
+	resp, err := s.client.post(path, forwardAttributes, forwardResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	forwardResponse.HttpResponse = resp
+	return forwardResponse, nil
+}
+
+// GetEmailForward fetches an email forward.
+//
+// See https://developer.dnsimple.com/v2/domains/email-forwards/#get
+func (s *DomainsService) GetEmailForward(accountID string, domainIdentifier string, forwardID int) (*emailForwardResponse, error) {
+	path := versioned(emailForwardPath(accountID, domainIdentifier, forwardID))
+	forwardResponse := &emailForwardResponse{}
+
+	resp, err := s.client.get(path, forwardResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	forwardResponse.HttpResponse = resp
+	return forwardResponse, nil
+}
+
+// DeleteEmailForward PERMANENTLY deletes an email forward from the domain.
+//
+// See https://developer.dnsimple.com/v2/domains/email-forwards/#delete
+func (s *DomainsService) DeleteEmailForward(accountID string, domainIdentifier string, forwardID int) (*emailForwardResponse, error) {
+	path := versioned(emailForwardPath(accountID, domainIdentifier, forwardID))
+	forwardResponse := &emailForwardResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	forwardResponse.HttpResponse = resp
+	return forwardResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/domains_pushes.go

@@ -0,0 +1,111 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// DomainPush represents a domain push in DNSimple.
+type DomainPush struct {
+	ID         int    `json:"id,omitempty"`
+	DomainID   int    `json:"domain_id,omitempty"`
+	ContactID  int    `json:"contact_id,omitempty"`
+	AccountID  int    `json:"account_id,omitempty"`
+	CreatedAt  string `json:"created_at,omitempty"`
+	UpdatedAt  string `json:"updated_at,omitempty"`
+	AcceptedAt string `json:"accepted_at,omitempty"`
+}
+
+func domainPushPath(accountID string, pushID int) (path string) {
+	path = fmt.Sprintf("/%v/pushes", accountID)
+	if pushID != 0 {
+		path += fmt.Sprintf("/%d", pushID)
+	}
+	return
+}
+
+// domainPushResponse represents a response from an API method that returns a DomainPush struct.
+type domainPushResponse struct {
+	Response
+	Data *DomainPush `json:"data"`
+}
+
+// domainPushesResponse represents a response from an API method that returns a collection of DomainPush struct.
+type domainPushesResponse struct {
+	Response
+	Data []DomainPush `json:"data"`
+}
+
+// DomainPushAttributes represent a domain push payload (see initiate).
+type DomainPushAttributes struct {
+	NewAccountEmail string `json:"new_account_email,omitempty"`
+	ContactID       string `json:"contact_id,omitempty"`
+}
+
+// InitiatePush initiate a new domain push.
+//
+// See https://developer.dnsimple.com/v2/domains/pushes/#initiate
+func (s *DomainsService) InitiatePush(accountID string, domainID string, pushAttributes DomainPushAttributes) (*domainPushResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/pushes", domainPath(accountID, domainID)))
+	pushResponse := &domainPushResponse{}
+
+	resp, err := s.client.post(path, pushAttributes, pushResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	pushResponse.HttpResponse = resp
+	return pushResponse, nil
+}
+
+// ListPushes lists the pushes for an account.
+//
+// See https://developer.dnsimple.com/v2/domains/pushes/#list
+func (s *DomainsService) ListPushes(accountID string, options *ListOptions) (*domainPushesResponse, error) {
+	path := versioned(domainPushPath(accountID, 0))
+	pushesResponse := &domainPushesResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, pushesResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	pushesResponse.HttpResponse = resp
+	return pushesResponse, nil
+}
+
+// AcceptPush accept a push for a domain.
+//
+// See https://developer.dnsimple.com/v2/domains/pushes/#accept
+func (s *DomainsService) AcceptPush(accountID string, pushID int, pushAttributes DomainPushAttributes) (*domainPushResponse, error) {
+	path := versioned(domainPushPath(accountID, pushID))
+	pushResponse := &domainPushResponse{}
+
+	resp, err := s.client.post(path, pushAttributes, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	pushResponse.HttpResponse = resp
+	return pushResponse, nil
+}
+
+// RejectPush reject a push for a domain.
+//
+// See https://developer.dnsimple.com/v2/domains/pushes/#reject
+func (s *DomainsService) RejectPush(accountID string, pushID int) (*domainPushResponse, error) {
+	path := versioned(domainPushPath(accountID, pushID))
+	pushResponse := &domainPushResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	pushResponse.HttpResponse = resp
+	return pushResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/identity.go

@@ -0,0 +1,48 @@
+package dnsimple
+
+// IdentityService handles communication with several authentication identity
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/identity/
+type IdentityService struct {
+	client *Client
+}
+
+// WhoamiData represents an authenticated context
+// that contains information about the current logged User and/or Account.
+type WhoamiData struct {
+	User    *User    `json:"user,omitempty"`
+	Account *Account `json:"account,omitempty"`
+}
+
+// whoamiResponse represents a response from an API method that returns a Whoami struct.
+type whoamiResponse struct {
+	Response
+	Data *WhoamiData `json:"data"`
+}
+
+// Whoami gets the current authenticate context.
+//
+// See https://developer.dnsimple.com/v2/whoami
+func (s *IdentityService) Whoami() (*whoamiResponse, error) {
+	path := versioned("/whoami")
+	whoamiResponse := &whoamiResponse{}
+
+	resp, err := s.client.get(path, whoamiResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	whoamiResponse.HttpResponse = resp
+	return whoamiResponse, nil
+}
+
+// Whoami is a state-less shortcut to client.Whoami()
+// that returns only the relevant Data.
+func Whoami(c *Client) (data *WhoamiData, err error) {
+	resp, err := c.Identity.Whoami()
+	if resp != nil {
+		data = resp.Data
+	}
+	return
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/oauth.go

@@ -0,0 +1,113 @@
+package dnsimple
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// GrantType is a string that identifies a particular grant type in the exchange request.
+type GrantType string
+
+const (
+	// AuthorizationCodeGrant is the type of access token request
+	// for an Authorization Code Grant flow.
+	// https://tools.ietf.org/html/rfc6749#section-4.1
+	AuthorizationCodeGrant = GrantType("authorization_code")
+)
+
+// OauthService handles communication with the authorization related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/oauth/
+type OauthService struct {
+	client *Client
+}
+
+// AccessToken represents a DNSimple Oauth access token.
+type AccessToken struct {
+	Token     string `json:"access_token"`
+	Type      string `json:"token_type"`
+	AccountID int    `json:"account_id"`
+}
+
+// ExchangeAuthorizationRequest represents a request to exchange
+// an authorization code for an access token.
+// RedirectURI is optional, all the other fields are mandatory.
+type ExchangeAuthorizationRequest struct {
+	Code         string    `json:"code"`
+	ClientID     string    `json:"client_id"`
+	ClientSecret string    `json:"client_secret"`
+	RedirectURI  string    `json:"redirect_uri,omitempty"`
+	State        string    `json:"state,omitempty"`
+	GrantType    GrantType `json:"grant_type,omitempty"`
+}
+
+// ExchangeAuthorizationError represents a failed request to exchange
+// an authorization code for an access token.
+type ExchangeAuthorizationError struct {
+	// HTTP response
+	HttpResponse *http.Response
+
+	ErrorCode        string `json:"error"`
+	ErrorDescription string `json:"error_description"`
+}
+
+// Error implements the error interface.
+func (r *ExchangeAuthorizationError) Error() string {
+	return fmt.Sprintf("%v %v: %v %v",
+		r.HttpResponse.Request.Method, r.HttpResponse.Request.URL,
+		r.ErrorCode, r.ErrorDescription)
+}
+
+// ExchangeAuthorizationForToken exchanges the short-lived authorization code for an access token
+// you can use to authenticate your API calls.
+func (s *OauthService) ExchangeAuthorizationForToken(authorization *ExchangeAuthorizationRequest) (*AccessToken, error) {
+	path := versioned("/oauth/access_token")
+
+	req, err := s.client.NewRequest("POST", path, authorization)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.HttpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		errorResponse := &ExchangeAuthorizationError{}
+		errorResponse.HttpResponse = resp
+		json.NewDecoder(resp.Body).Decode(errorResponse)
+		return nil, errorResponse
+	}
+
+	accessToken := &AccessToken{}
+	err = json.NewDecoder(resp.Body).Decode(accessToken)
+
+	return accessToken, err
+}
+
+// AuthorizationOptions represents the option you can use to generate an authorization URL.
+type AuthorizationOptions struct {
+	RedirectURI string `url:"redirect_uri,omitempty"`
+	// A randomly generated string to verify the validity of the request.
+	// Currently "state" is required by the DNSimple OAuth implementation, so you must specify it.
+	State string `url:"state,omitempty"`
+}
+
+// AuthorizeURL generates the URL to authorize an user for an application via the OAuth2 flow.
+func (s *OauthService) AuthorizeURL(clientID string, options *AuthorizationOptions) string {
+	uri, _ := url.Parse(strings.Replace(s.client.BaseURL, "api.", "", 1))
+	uri.Path = "/oauth/authorize"
+	query := uri.Query()
+	query.Add("client_id", clientID)
+	query.Add("response_type", "code")
+	uri.RawQuery = query.Encode()
+
+	path, _ := addURLQueryOptions(uri.String(), options)
+	return path
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/registrar.go

@@ -0,0 +1,258 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// RegistrarService handles communication with the registrar related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/registrar/
+type RegistrarService struct {
+	client *Client
+}
+
+// DomainCheck represents the result of a domain check.
+type DomainCheck struct {
+	Domain    string `json:"domain"`
+	Available bool   `json:"available"`
+	Premium   bool   `json:"premium"`
+}
+
+// domainCheckResponse represents a response from a domain check request.
+type domainCheckResponse struct {
+	Response
+	Data *DomainCheck `json:"data"`
+}
+
+// CheckDomain checks a domain name.
+//
+// See https://developer.dnsimple.com/v2/registrar/#check
+func (s *RegistrarService) CheckDomain(accountID, domainName string) (*domainCheckResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/check", accountID, domainName))
+	checkResponse := &domainCheckResponse{}
+
+	resp, err := s.client.get(path, checkResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	checkResponse.HttpResponse = resp
+	return checkResponse, nil
+}
+
+// DomainPremiumPrice represents the premium price for a premium domain.
+type DomainPremiumPrice struct {
+	// The domain premium price
+	PremiumPrice string `json:"premium_price"`
+	// The registrar action.
+	// Possible values are registration|transfer|renewal
+	Action string `json:"action"`
+}
+
+// domainPremiumPriceResponse represents a response from a domain premium price request.
+type domainPremiumPriceResponse struct {
+	Response
+	Data *DomainPremiumPrice `json:"data"`
+}
+
+// DomainPremiumPriceOptions specifies the optional parameters you can provide
+// to customize the RegistrarService.GetDomainPremiumPrice method.
+type DomainPremiumPriceOptions struct {
+	Action string `url:"action,omitempty"`
+}
+
+// Gets the premium price for a domain.
+//
+// You must specify an action to get the price for. Valid actions are:
+// - registration
+// - transfer
+// - renewal
+//
+// See https://developer.dnsimple.com/v2/registrar/#premium-price
+func (s *RegistrarService) GetDomainPremiumPrice(accountID, domainName string, options *DomainPremiumPriceOptions) (*domainPremiumPriceResponse, error) {
+	var err error
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/premium_price", accountID, domainName))
+	priceResponse := &domainPremiumPriceResponse{}
+
+	if options != nil {
+		path, err = addURLQueryOptions(path, options)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	resp, err := s.client.get(path, priceResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	priceResponse.HttpResponse = resp
+	return priceResponse, nil
+}
+
+// DomainRegistration represents the result of a domain renewal call.
+type DomainRegistration struct {
+	ID           int    `json:"id"`
+	DomainID     int    `json:"domain_id"`
+	RegistrantID int    `json:"registrant_id"`
+	Period       int    `json:"period"`
+	State        string `json:"state"`
+	AutoRenew    bool   `json:"auto_renew"`
+	WhoisPrivacy bool   `json:"whois_privacy"`
+	PremiumPrice string `json:"premium_price"`
+	CreatedAt    string `json:"created_at,omitempty"`
+	UpdatedAt    string `json:"updated_at,omitempty"`
+}
+
+// domainRegistrationResponse represents a response from an API method that results in a domain registration.
+type domainRegistrationResponse struct {
+	Response
+	Data *DomainRegistration `json:"data"`
+}
+
+// DomainRegisterRequest represents the attributes you can pass to a register API request.
+// Some attributes are mandatory.
+type DomainRegisterRequest struct {
+	// The ID of the Contact to use as registrant for the domain
+	RegistrantID int `json:"registrant_id"`
+	// Set to true to enable the whois privacy service. An extra cost may apply.
+	// Default to false.
+	EnableWhoisPrivacy bool `json:"whois_privacy,omitempty"`
+	// Set to true to enable the auto-renewal of the domain.
+	// Default to true.
+	EnableAutoRenewal bool `json:"auto_renew,omitempty"`
+}
+
+// RegisterDomain registers a domain name.
+//
+// See https://developer.dnsimple.com/v2/registrar/#register
+func (s *RegistrarService) RegisterDomain(accountID string, domainName string, request *DomainRegisterRequest) (*domainRegistrationResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/registrations", accountID, domainName))
+	registrationResponse := &domainRegistrationResponse{}
+
+	// TODO: validate mandatory attributes RegistrantID
+
+	resp, err := s.client.post(path, request, registrationResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	registrationResponse.HttpResponse = resp
+	return registrationResponse, nil
+}
+
+// DomainTransfer represents the result of a domain renewal call.
+type DomainTransfer struct {
+	ID           int    `json:"id"`
+	DomainID     int    `json:"domain_id"`
+	RegistrantID int    `json:"registrant_id"`
+	State        string `json:"state"`
+	AutoRenew    bool   `json:"auto_renew"`
+	WhoisPrivacy bool   `json:"whois_privacy"`
+	PremiumPrice string `json:"premium_price"`
+	CreatedAt    string `json:"created_at,omitempty"`
+	UpdatedAt    string `json:"updated_at,omitempty"`
+}
+
+// domainTransferResponse represents a response from an API method that results in a domain transfer.
+type domainTransferResponse struct {
+	Response
+	Data *DomainTransfer `json:"data"`
+}
+
+// DomainTransferRequest represents the attributes you can pass to a transfer API request.
+// Some attributes are mandatory.
+type DomainTransferRequest struct {
+	// The ID of the Contact to use as registrant for the domain
+	RegistrantID int `json:"registrant_id"`
+	// The Auth-Code required to transfer the domain.
+	// This is provided by the current registrar of the domain.
+	AuthCode string `json:"auth_code,omitempty"`
+	// Set to true to enable the whois privacy service. An extra cost may apply.
+	// Default to false.
+	EnableWhoisPrivacy bool `json:"whois_privacy,omitempty"`
+	// Set to true to enable the auto-renewal of the domain.
+	// Default to true.
+	EnableAutoRenewal bool `json:"auto_renew,omitempty"`
+}
+
+// TransferDomain transfers a domain name.
+//
+// See https://developer.dnsimple.com/v2/registrar/#transfer
+func (s *RegistrarService) TransferDomain(accountID string, domainName string, request *DomainTransferRequest) (*domainTransferResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/transfers", accountID, domainName))
+	transferResponse := &domainTransferResponse{}
+
+	// TODO: validate mandatory attributes RegistrantID
+
+	resp, err := s.client.post(path, request, transferResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	transferResponse.HttpResponse = resp
+	return transferResponse, nil
+}
+
+// domainTransferOutResponse represents a response from an API method that results in a domain transfer out.
+type domainTransferOutResponse struct {
+	Response
+	Data *Domain `json:"data"`
+}
+
+// Transfer out a domain name.
+//
+// See https://developer.dnsimple.com/v2/registrar/#transfer-out
+func (s *RegistrarService) TransferDomainOut(accountID string, domainName string) (*domainTransferOutResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/authorize_transfer_out", accountID, domainName))
+	transferResponse := &domainTransferOutResponse{}
+
+	resp, err := s.client.post(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	transferResponse.HttpResponse = resp
+	return transferResponse, nil
+}
+
+// DomainRenewal represents the result of a domain renewal call.
+type DomainRenewal struct {
+	ID           int    `json:"id"`
+	DomainID     int    `json:"domain_id"`
+	Period       int    `json:"period"`
+	State        string `json:"state"`
+	PremiumPrice string `json:"premium_price"`
+	CreatedAt    string `json:"created_at,omitempty"`
+	UpdatedAt    string `json:"updated_at,omitempty"`
+}
+
+// domainRenewalResponse represents a response from an API method that returns a domain renewal.
+type domainRenewalResponse struct {
+	Response
+	Data *DomainRenewal `json:"data"`
+}
+
+// DomainRenewRequest represents the attributes you can pass to a renew API request.
+// Some attributes are mandatory.
+type DomainRenewRequest struct {
+	// The number of years
+	Period int `json:"period"`
+}
+
+// RenewDomain renews a domain name.
+//
+// See https://developer.dnsimple.com/v2/registrar/#register
+func (s *RegistrarService) RenewDomain(accountID string, domainName string, request *DomainRenewRequest) (*domainRenewalResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/renewals", accountID, domainName))
+	renewalResponse := &domainRenewalResponse{}
+
+	resp, err := s.client.post(path, request, renewalResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	renewalResponse.HttpResponse = resp
+	return renewalResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/registrar_auto_renewal.go

@@ -0,0 +1,37 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// EnableDomainAutoRenewal enables auto-renewal for the domain.
+//
+// See https://developer.dnsimple.com/v2/registrar/auto-renewal/#enable
+func (s *RegistrarService) EnableDomainAutoRenewal(accountID string, domainName string) (*domainResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/auto_renewal", accountID, domainName))
+	domainResponse := &domainResponse{}
+
+	resp, err := s.client.put(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	domainResponse.HttpResponse = resp
+	return domainResponse, nil
+}
+
+// DisableDomainAutoRenewal disables auto-renewal for the domain.
+//
+// See https://developer.dnsimple.com/v2/registrar/auto-renewal/#enable
+func (s *RegistrarService) DisableDomainAutoRenewal(accountID string, domainName string) (*domainResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/auto_renewal", accountID, domainName))
+	domainResponse := &domainResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	domainResponse.HttpResponse = resp
+	return domainResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/registrar_delegation.go

@@ -0,0 +1,84 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// Delegation represents a list of name servers that correspond to a domain delegation.
+type Delegation []string
+
+// delegationResponse represents a response from an API method that returns a delegation struct.
+type delegationResponse struct {
+	Response
+	Data *Delegation `json:"data"`
+}
+
+// vanityDelegationResponse represents a response for vanity name server enable and disable operations.
+type vanityDelegationResponse struct {
+	Response
+	Data []VanityNameServer `json:"data"`
+}
+
+// GetDomainDelegation gets the current delegated name servers for the domain.
+//
+// See https://developer.dnsimple.com/v2/registrar/delegation/#get
+func (s *RegistrarService) GetDomainDelegation(accountID string, domainName string) (*delegationResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/delegation", accountID, domainName))
+	delegationResponse := &delegationResponse{}
+
+	resp, err := s.client.get(path, delegationResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	delegationResponse.HttpResponse = resp
+	return delegationResponse, nil
+}
+
+// ChangeDomainDelegation updates the delegated name severs for the domain.
+//
+// See https://developer.dnsimple.com/v2/registrar/delegation/#get
+func (s *RegistrarService) ChangeDomainDelegation(accountID string, domainName string, newDelegation *Delegation) (*delegationResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/delegation", accountID, domainName))
+	delegationResponse := &delegationResponse{}
+
+	resp, err := s.client.put(path, newDelegation, delegationResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	delegationResponse.HttpResponse = resp
+	return delegationResponse, nil
+}
+
+// ChangeDomainDelegationToVanity enables vanity name servers for the given domain.
+//
+// See https://developer.dnsimple.com/v2/registrar/delegation/#delegateToVanity
+func (s *RegistrarService) ChangeDomainDelegationToVanity(accountID string, domainName string, newDelegation *Delegation) (*vanityDelegationResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/delegation/vanity", accountID, domainName))
+	delegationResponse := &vanityDelegationResponse{}
+
+	resp, err := s.client.put(path, newDelegation, delegationResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	delegationResponse.HttpResponse = resp
+	return delegationResponse, nil
+}
+
+// ChangeDomainDelegationFromVanity disables vanity name servers for the given domain.
+//
+// See https://developer.dnsimple.com/v2/registrar/delegation/#dedelegateFromVanity
+func (s *RegistrarService) ChangeDomainDelegationFromVanity(accountID string, domainName string) (*vanityDelegationResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/delegation/vanity", accountID, domainName))
+	delegationResponse := &vanityDelegationResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	delegationResponse.HttpResponse = resp
+	return delegationResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/registrar_whois_privacy.go

@@ -0,0 +1,69 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// WhoisPrivacy represents a whois privacy in DNSimple.
+type WhoisPrivacy struct {
+	ID        int    `json:"id,omitempty"`
+	DomainID  int    `json:"domain_id,omitempty"`
+	Enabled   bool   `json:"enabled,omitempty"`
+	ExpiresOn string `json:"expires_on,omitempty"`
+	CreatedAt string `json:"created_at,omitempty"`
+	UpdatedAt string `json:"updated_at,omitempty"`
+}
+
+// whoisPrivacyResponse represents a response from an API method that returns a WhoisPrivacy struct.
+type whoisPrivacyResponse struct {
+	Response
+	Data *WhoisPrivacy `json:"data"`
+}
+
+// GetWhoisPrivacy gets the whois privacy for the domain.
+//
+// See https://developer.dnsimple.com/v2/registrar/whois-privacy/#get
+func (s *RegistrarService) GetWhoisPrivacy(accountID string, domainName string) (*whoisPrivacyResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/whois_privacy", accountID, domainName))
+	privacyResponse := &whoisPrivacyResponse{}
+
+	resp, err := s.client.get(path, privacyResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	privacyResponse.HttpResponse = resp
+	return privacyResponse, nil
+}
+
+// EnableWhoisPrivacy enables the whois privacy for the domain.
+//
+// See https://developer.dnsimple.com/v2/registrar/whois-privacy/#enable
+func (s *RegistrarService) EnableWhoisPrivacy(accountID string, domainName string) (*whoisPrivacyResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/whois_privacy", accountID, domainName))
+	privacyResponse := &whoisPrivacyResponse{}
+
+	resp, err := s.client.put(path, nil, privacyResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	privacyResponse.HttpResponse = resp
+	return privacyResponse, nil
+}
+
+// DisablePrivacy disables the whois privacy for the domain.
+//
+// See https://developer.dnsimple.com/v2/registrar/whois-privacy/#enable
+func (s *RegistrarService) DisableWhoisPrivacy(accountID string, domainName string) (*whoisPrivacyResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/registrar/domains/%v/whois_privacy", accountID, domainName))
+	privacyResponse := &whoisPrivacyResponse{}
+
+	resp, err := s.client.delete(path, nil, privacyResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	privacyResponse.HttpResponse = resp
+	return privacyResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/services.go

@@ -0,0 +1,94 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// ServicesService handles communication with the service related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/services/
+type ServicesService struct {
+	client *Client
+}
+
+// Service represents a Service in DNSimple.
+type Service struct {
+	ID               int              `json:"id,omitempty"`
+	SID              string           `json:"sid,omitempty"`
+	Name             string           `json:"name,omitempty"`
+	Description      string           `json:"description,omitempty"`
+	SetupDescription string           `json:"setup_description,omitempty"`
+	RequiresSetup    bool             `json:"requires_setup,omitempty"`
+	DefaultSubdomain string           `json:"default_subdomain,omitempty"`
+	CreatedAt        string           `json:"created_at,omitempty"`
+	UpdatedAt        string           `json:"updated_at,omitempty"`
+	Settings         []ServiceSetting `json:"settings,omitempty"`
+}
+
+// ServiceSetting represents a single group of settings for a DNSimple Service.
+type ServiceSetting struct {
+	Name        string `json:"name,omitempty"`
+	Label       string `json:"label,omitempty"`
+	Append      string `json:"append,omitempty"`
+	Description string `json:"description,omitempty"`
+	Example     string `json:"example,omitempty"`
+	Password    bool   `json:"password,omitempty"`
+}
+
+func servicePath(serviceID string) (path string) {
+	path = "/services"
+	if serviceID != "" {
+		path += fmt.Sprintf("/%v", serviceID)
+	}
+	return
+}
+
+// serviceResponse represents a response from an API method that returns a Service struct.
+type serviceResponse struct {
+	Response
+	Data *Service `json:"data"`
+}
+
+// servicesResponse represents a response from an API method that returns a collection of Service struct.
+type servicesResponse struct {
+	Response
+	Data []Service `json:"data"`
+}
+
+// ListServices lists the one-click services available in DNSimple.
+//
+// See https://developer.dnsimple.com/v2/services/#list
+func (s *ServicesService) ListServices(options *ListOptions) (*servicesResponse, error) {
+	path := versioned(servicePath(""))
+	servicesResponse := &servicesResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, servicesResponse)
+	if err != nil {
+		return servicesResponse, err
+	}
+
+	servicesResponse.HttpResponse = resp
+	return servicesResponse, nil
+}
+
+// GetService fetches a one-click service.
+//
+// See https://developer.dnsimple.com/v2/services/#get
+func (s *ServicesService) GetService(serviceIdentifier string) (*serviceResponse, error) {
+	path := versioned(servicePath(serviceIdentifier))
+	serviceResponse := &serviceResponse{}
+
+	resp, err := s.client.get(path, serviceResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	serviceResponse.HttpResponse = resp
+	return serviceResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/services_domains.go

@@ -0,0 +1,70 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+func domainServicesPath(accountID string, domainID string, serviceIdentifier string) string {
+	if serviceIdentifier != "" {
+		return fmt.Sprintf("/%v/domains/%v/services/%v", accountID, domainID, serviceIdentifier)
+	}
+	return fmt.Sprintf("/%v/domains/%v/services", accountID, domainID)
+}
+
+// DomainServiceSettings represents optional settings when applying a DNSimple one-click service to a domain.
+type DomainServiceSettings struct {
+	Settings map[string]string `url:"settings,omitempty"`
+}
+
+// AppliedServices lists the applied one-click services for a domain.
+//
+// See https://developer.dnsimple.com/v2/services/domains/#applied
+func (s *ServicesService) AppliedServices(accountID string, domainID string, options *ListOptions) (*servicesResponse, error) {
+	path := versioned(domainServicesPath(accountID, domainID, ""))
+	servicesResponse := &servicesResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, servicesResponse)
+	if err != nil {
+		return servicesResponse, err
+	}
+
+	servicesResponse.HttpResponse = resp
+	return servicesResponse, nil
+}
+
+// ApplyService applies a one-click services to a domain.
+//
+// See https://developer.dnsimple.com/v2/services/domains/#apply
+func (s *ServicesService) ApplyService(accountID string, serviceIdentifier string, domainID string, settings DomainServiceSettings) (*serviceResponse, error) {
+	path := versioned(domainServicesPath(accountID, domainID, serviceIdentifier))
+	serviceResponse := &serviceResponse{}
+
+	resp, err := s.client.post(path, settings, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	serviceResponse.HttpResponse = resp
+	return serviceResponse, nil
+}
+
+// UnapplyService unapplies a one-click services from a domain.
+//
+// See https://developer.dnsimple.com/v2/services/domains/#unapply
+func (s *ServicesService) UnapplyService(accountID string, serviceIdentifier string, domainID string) (*serviceResponse, error) {
+	path := versioned(domainServicesPath(accountID, domainID, serviceIdentifier))
+	serviceResponse := &serviceResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	serviceResponse.HttpResponse = resp
+	return serviceResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/templates.go

@@ -0,0 +1,129 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// TemplatesService handles communication with the template related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/templates/
+type TemplatesService struct {
+	client *Client
+}
+
+// Template represents a Template in DNSimple.
+type Template struct {
+	ID          int    `json:"id,omitempty"`
+	SID         string `json:"sid,omitempty"`
+	AccountID   int    `json:"account_id,omitempty"`
+	Name        string `json:"name,omitempty"`
+	Description string `json:"description,omitempty"`
+	CreatedAt   string `json:"created_at,omitempty"`
+	UpdatedAt   string `json:"updated_at,omitempty"`
+}
+
+func templatePath(accountID string, templateIdentifier string) (path string) {
+	path = fmt.Sprintf("/%v/templates", accountID)
+	if templateIdentifier != "" {
+		path += fmt.Sprintf("/%v", templateIdentifier)
+	}
+	return
+}
+
+// templateResponse represents a response from an API method that returns a Template struct.
+type templateResponse struct {
+	Response
+	Data *Template `json:"data"`
+}
+
+// templatesResponse represents a response from an API method that returns a collection of Template struct.
+type templatesResponse struct {
+	Response
+	Data []Template `json:"data"`
+}
+
+// ListTemplates list the templates for an account.
+//
+// See https://developer.dnsimple.com/v2/templates/#list
+func (s *TemplatesService) ListTemplates(accountID string, options *ListOptions) (*templatesResponse, error) {
+	path := versioned(templatePath(accountID, ""))
+	templatesResponse := &templatesResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, templatesResponse)
+	if err != nil {
+		return templatesResponse, err
+	}
+
+	templatesResponse.HttpResponse = resp
+	return templatesResponse, nil
+}
+
+// CreateTemplate creates a new template.
+//
+// See https://developer.dnsimple.com/v2/templates/#create
+func (s *TemplatesService) CreateTemplate(accountID string, templateAttributes Template) (*templateResponse, error) {
+	path := versioned(templatePath(accountID, ""))
+	templateResponse := &templateResponse{}
+
+	resp, err := s.client.post(path, templateAttributes, templateResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	templateResponse.HttpResponse = resp
+	return templateResponse, nil
+}
+
+// GetTemplate fetches a template.
+//
+// See https://developer.dnsimple.com/v2/templates/#get
+func (s *TemplatesService) GetTemplate(accountID string, templateIdentifier string) (*templateResponse, error) {
+	path := versioned(templatePath(accountID, templateIdentifier))
+	templateResponse := &templateResponse{}
+
+	resp, err := s.client.get(path, templateResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	templateResponse.HttpResponse = resp
+	return templateResponse, nil
+}
+
+// UpdateTemplate updates a template.
+//
+// See https://developer.dnsimple.com/v2/templates/#update
+func (s *TemplatesService) UpdateTemplate(accountID string, templateIdentifier string, templateAttributes Template) (*templateResponse, error) {
+	path := versioned(templatePath(accountID, templateIdentifier))
+	templateResponse := &templateResponse{}
+
+	resp, err := s.client.patch(path, templateAttributes, templateResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	templateResponse.HttpResponse = resp
+	return templateResponse, nil
+}
+
+// DeleteTemplate deletes a template.
+//
+// See https://developer.dnsimple.com/v2/templates/#delete
+func (s *TemplatesService) DeleteTemplate(accountID string, templateIdentifier string) (*templateResponse, error) {
+	path := versioned(templatePath(accountID, templateIdentifier))
+	templateResponse := &templateResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	templateResponse.HttpResponse = resp
+	return templateResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/templates_domains.go

@@ -0,0 +1,21 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// ApplyTemplate applies a template to the given domain.
+//
+// See https://developer.dnsimple.com/v2/templates/domains/#apply
+func (s *TemplatesService) ApplyTemplate(accountID string, templateIdentifier string, domainID string) (*templateResponse, error) {
+	path := versioned(fmt.Sprintf("%v/templates/%v", domainPath(accountID, domainID), templateIdentifier))
+	templateResponse := &templateResponse{}
+
+	resp, err := s.client.post(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	templateResponse.HttpResponse = resp
+	return templateResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/templates_records.go

@@ -0,0 +1,107 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// TemplateRecord represents a DNS record for a template in DNSimple.
+type TemplateRecord struct {
+	ID         int    `json:"id,omitempty"`
+	TemplateID int    `json:"template_id,omitempty"`
+	Name       string `json:"name"`
+	Content    string `json:"content,omitempty"`
+	TTL        int    `json:"ttl,omitempty"`
+	Type       string `json:"type,omitempty"`
+	Priority   int    `json:"priority,omitempty"`
+	CreatedAt  string `json:"created_at,omitempty"`
+	UpdatedAt  string `json:"updated_at,omitempty"`
+}
+
+func templateRecordPath(accountID string, templateIdentifier string, templateRecordID string) string {
+	if templateRecordID != "" {
+		return fmt.Sprintf("%v/records/%v", templatePath(accountID, templateIdentifier), templateRecordID)
+	}
+
+	return templatePath(accountID, templateIdentifier) + "/records"
+}
+
+// templateRecordResponse represents a response from an API method that returns a TemplateRecord struct.
+type templateRecordResponse struct {
+	Response
+	Data *TemplateRecord `json:"data"`
+}
+
+// templateRecordsResponse represents a response from an API method that returns a collection of TemplateRecord struct.
+type templateRecordsResponse struct {
+	Response
+	Data []TemplateRecord `json:"data"`
+}
+
+// ListTemplateRecords list the templates for an account.
+//
+// See https://developer.dnsimple.com/v2/templates/records/#list
+func (s *TemplatesService) ListTemplateRecords(accountID string, templateIdentifier string, options *ListOptions) (*templateRecordsResponse, error) {
+	path := versioned(templateRecordPath(accountID, templateIdentifier, ""))
+	templateRecordsResponse := &templateRecordsResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, templateRecordsResponse)
+	if err != nil {
+		return templateRecordsResponse, err
+	}
+
+	templateRecordsResponse.HttpResponse = resp
+	return templateRecordsResponse, nil
+}
+
+// CreateTemplateRecord creates a new template record.
+//
+// See https://developer.dnsimple.com/v2/templates/records/#create
+func (s *TemplatesService) CreateTemplateRecord(accountID string, templateIdentifier string, templateRecordAttributes TemplateRecord) (*templateRecordResponse, error) {
+	path := versioned(templateRecordPath(accountID, templateIdentifier, ""))
+	templateRecordResponse := &templateRecordResponse{}
+
+	resp, err := s.client.post(path, templateRecordAttributes, templateRecordResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	templateRecordResponse.HttpResponse = resp
+	return templateRecordResponse, nil
+}
+
+// GetTemplateRecord fetches a template record.
+//
+// See https://developer.dnsimple.com/v2/templates/records/#get
+func (s *TemplatesService) GetTemplateRecord(accountID string, templateIdentifier string, templateRecordID string) (*templateRecordResponse, error) {
+	path := versioned(templateRecordPath(accountID, templateIdentifier, templateRecordID))
+	templateRecordResponse := &templateRecordResponse{}
+
+	resp, err := s.client.get(path, templateRecordResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	templateRecordResponse.HttpResponse = resp
+	return templateRecordResponse, nil
+}
+
+// DeleteTemplateRecord deletes a template record.
+//
+// See https://developer.dnsimple.com/v2/templates/records/#delete
+func (s *TemplatesService) DeleteTemplateRecord(accountID string, templateIdentifier string, templateRecordID string) (*templateRecordResponse, error) {
+	path := versioned(templateRecordPath(accountID, templateIdentifier, templateRecordID))
+	templateRecordResponse := &templateRecordResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	templateRecordResponse.HttpResponse = resp
+	return templateRecordResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/tlds.go

@@ -0,0 +1,117 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// TldsService handles communication with the Tld related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/tlds/
+type TldsService struct {
+	client *Client
+}
+
+// Tld represents a TLD in DNSimple.
+type Tld struct {
+	Tld                 string `json:"tld"`
+	TldType             int    `json:"tld_type"`
+	WhoisPrivacy        bool   `json:"whois_privacy"`
+	AutoRenewOnly       bool   `json:"auto_renew_only"`
+	MinimumRegistration int    `json:"minimum_registration"`
+	RegistrationEnabled bool   `json:"registration_enabled"`
+	RenewalEnabled      bool   `json:"renewal_enabled"`
+	TransferEnabled     bool   `json:"transfer_enabled"`
+}
+
+// TldExtendedAttribute represents an extended attributes supported or required
+// by a specific TLD.
+//
+// See https://developer.dnsimple.com/v2/tlds/
+type TldExtendedAttribute struct {
+	Name        string                       `json:"name"`
+	Description string                       `json:"description"`
+	Required    bool                         `json:"required"`
+	Options     []TldExtendedAttributeOption `json:"options"`
+}
+
+// TldExtendedAttributeOption represents a single option you can assign to an extended attributes.
+//
+// See https://developer.dnsimple.com/v2/tlds/
+type TldExtendedAttributeOption struct {
+	Title       string `json:"title"`
+	Value       string `json:"value"`
+	Description string `json:"description"`
+}
+
+// tldResponse represents a response from an API method that returns a Tld struct.
+type tldResponse struct {
+	Response
+	Data *Tld `json:"data"`
+}
+
+// tldsResponse represents a response from an API method that returns a collection of Tld struct.
+type tldsResponse struct {
+	Response
+	Data []Tld `json:"data"`
+}
+
+// tldExtendedAttributesResponse represents a response from an API method that returns
+// a collection of Tld extended attributes.
+type tldExtendedAttributesResponse struct {
+	Response
+	Data []TldExtendedAttribute `json:"data"`
+}
+
+// ListTlds lists the supported TLDs.
+//
+// See https://developer.dnsimple.com/v2/tlds/#list
+func (s *TldsService) ListTlds(options *ListOptions) (*tldsResponse, error) {
+	path := versioned("/tlds")
+	tldsResponse := &tldsResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, tldsResponse)
+	if err != nil {
+		return tldsResponse, err
+	}
+
+	tldsResponse.HttpResponse = resp
+	return tldsResponse, nil
+}
+
+// GetTld fetches a TLD.
+//
+// See https://developer.dnsimple.com/v2/tlds/#get
+func (s *TldsService) GetTld(tld string) (*tldResponse, error) {
+	path := versioned(fmt.Sprintf("/tlds/%s", tld))
+	tldResponse := &tldResponse{}
+
+	resp, err := s.client.get(path, tldResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	tldResponse.HttpResponse = resp
+	return tldResponse, nil
+}
+
+// GetTld fetches the extended attributes of a TLD.
+//
+// See https://developer.dnsimple.com/v2/tlds/#get
+func (s *TldsService) GetTldExtendedAttributes(tld string) (*tldExtendedAttributesResponse, error) {
+	path := versioned(fmt.Sprintf("/tlds/%s/extended_attributes", tld))
+	tldResponse := &tldExtendedAttributesResponse{}
+
+	resp, err := s.client.get(path, tldResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	tldResponse.HttpResponse = resp
+	return tldResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/users.go

@@ -0,0 +1,7 @@
+package dnsimple
+
+// User represents a DNSimple user.
+type User struct {
+	ID    int    `json:"id,omitempty"`
+	Email string `json:"email,omitempty"`
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/vanity_name_server.go

@@ -0,0 +1,65 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// VanityNameServersService handles communication with Vanity Name Servers
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/vanity/
+type VanityNameServersService struct {
+	client *Client
+}
+
+// VanityNameServer represents data for a single vanity name server
+type VanityNameServer struct {
+	ID        int    `json:"id,omitempty"`
+	Name      string `json:"name,omitempty"`
+	IPv4      string `json:"ipv4,omitempty"`
+	IPv6      string `json:"ipv6,omitempty"`
+	CreatedAt string `json:"created_at,omitempty"`
+	UpdatedAt string `json:"updated_at,omitempty"`
+}
+
+func vanityNameServerPath(accountID string, domainID string) string {
+	return fmt.Sprintf("/%v/vanity/%v", accountID, domainID)
+}
+
+// vanityNameServerResponse represents a response for vanity name server enable and disable operations.
+type vanityNameServerResponse struct {
+	Response
+	Data []VanityNameServer `json:"data"`
+}
+
+// EnableVanityNameServers Vanity Name Servers for the given domain
+//
+// See https://developer.dnsimple.com/v2/vanity/#enable
+func (s *VanityNameServersService) EnableVanityNameServers(accountID string, domainID string) (*vanityNameServerResponse, error) {
+	path := versioned(vanityNameServerPath(accountID, domainID))
+	vanityNameServerResponse := &vanityNameServerResponse{}
+
+	resp, err := s.client.put(path, nil, vanityNameServerResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	vanityNameServerResponse.HttpResponse = resp
+	return vanityNameServerResponse, nil
+}
+
+// DisableVanityNameServers Vanity Name Servers for the given domain
+//
+// See https://developer.dnsimple.com/v2/vanity/#disable
+func (s *VanityNameServersService) DisableVanityNameServers(accountID string, domainID string) (*vanityNameServerResponse, error) {
+	path := versioned(vanityNameServerPath(accountID, domainID))
+	vanityNameServerResponse := &vanityNameServerResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	vanityNameServerResponse.HttpResponse = resp
+	return vanityNameServerResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/webhooks.go

@@ -0,0 +1,103 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// WebhooksService handles communication with the webhook related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/webhooks
+type WebhooksService struct {
+	client *Client
+}
+
+// Webhook represents a DNSimple webhook.
+type Webhook struct {
+	ID  int    `json:"id,omitempty"`
+	URL string `json:"url,omitempty"`
+}
+
+func webhookPath(accountID string, webhookID int) (path string) {
+	path = fmt.Sprintf("/%v/webhooks", accountID)
+	if webhookID != 0 {
+		path = fmt.Sprintf("%v/%v", path, webhookID)
+	}
+	return
+}
+
+// webhookResponse represents a response from an API method that returns a Webhook struct.
+type webhookResponse struct {
+	Response
+	Data *Webhook `json:"data"`
+}
+
+// webhookResponse represents a response from an API method that returns a collection of Webhook struct.
+type webhooksResponse struct {
+	Response
+	Data []Webhook `json:"data"`
+}
+
+// ListWebhooks lists the webhooks for an account.
+//
+// See https://developer.dnsimple.com/v2/webhooks#list
+func (s *WebhooksService) ListWebhooks(accountID string, _ *ListOptions) (*webhooksResponse, error) {
+	path := versioned(webhookPath(accountID, 0))
+	webhooksResponse := &webhooksResponse{}
+
+	resp, err := s.client.get(path, webhooksResponse)
+	if err != nil {
+		return webhooksResponse, err
+	}
+
+	webhooksResponse.HttpResponse = resp
+	return webhooksResponse, nil
+}
+
+// CreateWebhook creates a new webhook.
+//
+// See https://developer.dnsimple.com/v2/webhooks#create
+func (s *WebhooksService) CreateWebhook(accountID string, webhookAttributes Webhook) (*webhookResponse, error) {
+	path := versioned(webhookPath(accountID, 0))
+	webhookResponse := &webhookResponse{}
+
+	resp, err := s.client.post(path, webhookAttributes, webhookResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	webhookResponse.HttpResponse = resp
+	return webhookResponse, nil
+}
+
+// GetWebhook fetches a webhook.
+//
+// See https://developer.dnsimple.com/v2/webhooks#get
+func (s *WebhooksService) GetWebhook(accountID string, webhookID int) (*webhookResponse, error) {
+	path := versioned(webhookPath(accountID, webhookID))
+	webhookResponse := &webhookResponse{}
+
+	resp, err := s.client.get(path, webhookResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	webhookResponse.HttpResponse = resp
+	return webhookResponse, nil
+}
+
+// DeleteWebhook PERMANENTLY deletes a webhook from the account.
+//
+// See https://developer.dnsimple.com/v2/webhooks#delete
+func (s *WebhooksService) DeleteWebhook(accountID string, webhookID int) (*webhookResponse, error) {
+	path := versioned(webhookPath(accountID, webhookID))
+	webhookResponse := &webhookResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	webhookResponse.HttpResponse = resp
+	return webhookResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/zones.go

@@ -0,0 +1,108 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// ZonesService handles communication with the zone related
+// methods of the DNSimple API.
+//
+// See https://developer.dnsimple.com/v2/zones/
+type ZonesService struct {
+	client *Client
+}
+
+// Zone represents a Zone in DNSimple.
+type Zone struct {
+	ID        int    `json:"id,omitempty"`
+	AccountID int    `json:"account_id,omitempty"`
+	Name      string `json:"name,omitempty"`
+	Reverse   bool   `json:"reverse,omitempty"`
+	CreatedAt string `json:"created_at,omitempty"`
+	UpdatedAt string `json:"updated_at,omitempty"`
+}
+
+// ZoneFile represents a Zone File in DNSimple.
+type ZoneFile struct {
+	Zone string `json:"zone,omitempty"`
+}
+
+// zoneResponse represents a response from an API method that returns a Zone struct.
+type zoneResponse struct {
+	Response
+	Data *Zone `json:"data"`
+}
+
+// zonesResponse represents a response from an API method that returns a collection of Zone struct.
+type zonesResponse struct {
+	Response
+	Data []Zone `json:"data"`
+}
+
+// zoneFileResponse represents a response from an API method that returns a ZoneFile struct.
+type zoneFileResponse struct {
+	Response
+	Data *ZoneFile `json:"data"`
+}
+
+// ZoneListOptions specifies the optional parameters you can provide
+// to customize the ZonesService.ListZones method.
+type ZoneListOptions struct {
+	// Select domains where the name contains given string.
+	NameLike string `url:"name_like,omitempty"`
+
+	ListOptions
+}
+
+// ListZones the zones for an account.
+//
+// See https://developer.dnsimple.com/v2/zones/#list
+func (s *ZonesService) ListZones(accountID string, options *ZoneListOptions) (*zonesResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/zones", accountID))
+	zonesResponse := &zonesResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, zonesResponse)
+	if err != nil {
+		return zonesResponse, err
+	}
+
+	zonesResponse.HttpResponse = resp
+	return zonesResponse, nil
+}
+
+// GetZone fetches a zone.
+//
+// See https://developer.dnsimple.com/v2/zones/#get
+func (s *ZonesService) GetZone(accountID string, zoneName string) (*zoneResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/zones/%v", accountID, zoneName))
+	zoneResponse := &zoneResponse{}
+
+	resp, err := s.client.get(path, zoneResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	zoneResponse.HttpResponse = resp
+	return zoneResponse, nil
+}
+
+// GetZoneFile fetches a zone file.
+//
+// See https://developer.dnsimple.com/v2/zones/#get-file
+func (s *ZonesService) GetZoneFile(accountID string, zoneName string) (*zoneFileResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/zones/%v/file", accountID, zoneName))
+	zoneFileResponse := &zoneFileResponse{}
+
+	resp, err := s.client.get(path, zoneFileResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	zoneFileResponse.HttpResponse = resp
+	return zoneFileResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/zones_records.go

@@ -0,0 +1,142 @@
+package dnsimple
+
+import (
+	"fmt"
+)
+
+// ZoneRecord represents a DNS record in DNSimple.
+type ZoneRecord struct {
+	ID           int      `json:"id,omitempty"`
+	ZoneID       string   `json:"zone_id,omitempty"`
+	ParentID     int      `json:"parent_id,omitempty"`
+	Type         string   `json:"type,omitempty"`
+	Name         string   `json:"name"`
+	Content      string   `json:"content,omitempty"`
+	TTL          int      `json:"ttl,omitempty"`
+	Priority     int      `json:"priority,omitempty"`
+	SystemRecord bool     `json:"system_record,omitempty"`
+	Regions      []string `json:"regions,omitempty"`
+	CreatedAt    string   `json:"created_at,omitempty"`
+	UpdatedAt    string   `json:"updated_at,omitempty"`
+}
+
+func zoneRecordPath(accountID string, zoneID string, recordID int) (path string) {
+	path = fmt.Sprintf("/%v/zones/%v/records", accountID, zoneID)
+	if recordID != 0 {
+		path += fmt.Sprintf("/%d", recordID)
+	}
+	return
+}
+
+// zoneRecordResponse represents a response from an API method that returns a ZoneRecord struct.
+type zoneRecordResponse struct {
+	Response
+	Data *ZoneRecord `json:"data"`
+}
+
+// zoneRecordsResponse represents a response from an API method that returns a collection of ZoneRecord struct.
+type zoneRecordsResponse struct {
+	Response
+	Data []ZoneRecord `json:"data"`
+}
+
+// ZoneRecordListOptions specifies the optional parameters you can provide
+// to customize the ZonesService.ListZoneRecords method.
+type ZoneRecordListOptions struct {
+	// Select records where the name matches given string.
+	Name string `url:"name,omitempty"`
+
+	// Select records where the name contains given string.
+	NameLike string `url:"name_like,omitempty"`
+
+	// Select records of given type.
+	// Eg. TXT, A, NS.
+	Type string `url:"record_type,omitempty"`
+
+	ListOptions
+}
+
+// ListRecords lists the zone records for a zone.
+//
+// See https://developer.dnsimple.com/v2/zones/#list
+func (s *ZonesService) ListRecords(accountID string, zoneID string, options *ZoneRecordListOptions) (*zoneRecordsResponse, error) {
+	path := versioned(zoneRecordPath(accountID, zoneID, 0))
+	recordsResponse := &zoneRecordsResponse{}
+
+	path, err := addURLQueryOptions(path, options)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.get(path, recordsResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	recordsResponse.HttpResponse = resp
+	return recordsResponse, nil
+}
+
+// CreateRecord creates a zone record.
+//
+// See https://developer.dnsimple.com/v2/zones/#create
+func (s *ZonesService) CreateRecord(accountID string, zoneID string, recordAttributes ZoneRecord) (*zoneRecordResponse, error) {
+	path := versioned(zoneRecordPath(accountID, zoneID, 0))
+	recordResponse := &zoneRecordResponse{}
+
+	resp, err := s.client.post(path, recordAttributes, recordResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	recordResponse.HttpResponse = resp
+	return recordResponse, nil
+}
+
+// GetRecord fetches a zone record.
+//
+// See https://developer.dnsimple.com/v2/zones/#get
+func (s *ZonesService) GetRecord(accountID string, zoneID string, recordID int) (*zoneRecordResponse, error) {
+	path := versioned(zoneRecordPath(accountID, zoneID, recordID))
+	recordResponse := &zoneRecordResponse{}
+
+	resp, err := s.client.get(path, recordResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	recordResponse.HttpResponse = resp
+	return recordResponse, nil
+}
+
+// UpdateRecord updates a zone record.
+//
+// See https://developer.dnsimple.com/v2/zones/#update
+func (s *ZonesService) UpdateRecord(accountID string, zoneID string, recordID int, recordAttributes ZoneRecord) (*zoneRecordResponse, error) {
+	path := versioned(zoneRecordPath(accountID, zoneID, recordID))
+	recordResponse := &zoneRecordResponse{}
+	resp, err := s.client.patch(path, recordAttributes, recordResponse)
+
+	if err != nil {
+		return nil, err
+	}
+
+	recordResponse.HttpResponse = resp
+	return recordResponse, nil
+}
+
+// DeleteRecord PERMANENTLY deletes a zone record from the zone.
+//
+// See https://developer.dnsimple.com/v2/zones/#delete
+func (s *ZonesService) DeleteRecord(accountID string, zoneID string, recordID int) (*zoneRecordResponse, error) {
+	path := versioned(zoneRecordPath(accountID, zoneID, recordID))
+	recordResponse := &zoneRecordResponse{}
+
+	resp, err := s.client.delete(path, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	recordResponse.HttpResponse = resp
+	return recordResponse, nil
+}

vendor/github.com/ghodss/yaml/fields.go

@@ -45,11 +45,7 @@ func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.Te
 			break
 		}
 		if v.IsNil() {
-			if v.CanSet() {
 			v.Set(reflect.New(v.Type().Elem()))
-			} else {
-				v = reflect.New(v.Type().Elem())
-			}
 		}
 		if v.Type().NumMethod() > 0 {
 			if u, ok := v.Interface().(json.Unmarshaler); ok {

vendor/github.com/ghodss/yaml/yaml.go

@@ -15,12 +15,12 @@ import (
 func Marshal(o interface{}) ([]byte, error) {
 	j, err := json.Marshal(o)
 	if err != nil {
-		return nil, fmt.Errorf("error marshaling into JSON: %v", err)
+		return nil, fmt.Errorf("error marshaling into JSON: ", err)
 	}
 
 	y, err := JSONToYAML(j)
 	if err != nil {
-		return nil, fmt.Errorf("error converting JSON to YAML: %v", err)
+		return nil, fmt.Errorf("error converting JSON to YAML: ", err)
 	}
 
 	return y, nil
@@ -48,7 +48,7 @@ func JSONToYAML(j []byte) ([]byte, error) {
 	var jsonObj interface{}
 	// We are using yaml.Unmarshal here (instead of json.Unmarshal) because the
 	// Go JSON library doesn't try to pick the right number type (int, float,
-	// etc.) when unmarshalling to interface{}, it just picks float64
+	// etc.) when unmarshling to interface{}, it just picks float64
 	// universally. go-yaml does go through the effort of picking the right
 	// number type, so we can preserve number type throughout this process.
 	err := yaml.Unmarshal(j, &jsonObj)

vendor/github.com/go-openapi/spec/expander.go

@@ -17,11 +17,7 @@ package spec
 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"net/url"
-	"os"
-	"path"
-	"path/filepath"
 	"reflect"
 	"strings"
 	"sync"
@@ -30,17 +26,6 @@ import (
 	"github.com/go-openapi/swag"
 )
 
-var (
-	// Debug enables logging when SWAGGER_DEBUG env var is not empty
-	Debug = os.Getenv("SWAGGER_DEBUG") != ""
-)
-
-// ExpandOptions provides options for expand.
-type ExpandOptions struct {
-	RelativeBase string
-	SkipSchemas  bool
-}
-
 // ResolutionCache a cache for resolving urls
 type ResolutionCache interface {
 	Get(string) (interface{}, bool)
@@ -52,11 +37,7 @@ type simpleCache struct {
 	store map[string]interface{}
 }
 
-var resCache ResolutionCache
+var resCache = initResolutionCache()
-
-func init() {
-	resCache = initResolutionCache()
-}
 
 func initResolutionCache() ResolutionCache {
 	return &simpleCache{store: map[string]interface{}{
@@ -66,11 +47,8 @@ func initResolutionCache() ResolutionCache {
 }
 
 func (s *simpleCache) Get(uri string) (interface{}, bool) {
-	debugLog("getting %q from resolution cache", uri)
 	s.lock.Lock()
 	v, ok := s.store[uri]
-	debugLog("got %q from resolution cache: %t", uri, ok)
-
 	s.lock.Unlock()
 	return v, ok
 }
@@ -81,9 +59,9 @@ func (s *simpleCache) Set(uri string, data interface{}) {
 	s.lock.Unlock()
 }
 
-// ResolveRefWithBase resolves a reference against a context root with preservation of base path
+// ResolveRef resolves a reference against a context root
-func ResolveRefWithBase(root interface{}, ref *Ref, opts *ExpandOptions) (*Schema, error) {
+func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
-	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
+	resolver, err := defaultSchemaLoader(root, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -95,19 +73,9 @@ func ResolveRefWithBase(root interface{}, ref *Ref, opts *ExpandOptions) (*Schem
 	return result, nil
 }
 
-// ResolveRef resolves a reference against a context root
-func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
-	return ResolveRefWithBase(root, ref, nil)
-}
-
 // ResolveParameter resolves a paramter reference against a context root
 func ResolveParameter(root interface{}, ref Ref) (*Parameter, error) {
-	return ResolveParameterWithBase(root, ref, nil)
+	resolver, err := defaultSchemaLoader(root, nil, nil)
-}
-
-// ResolveParameterWithBase resolves a paramter reference against a context root and base path
-func ResolveParameterWithBase(root interface{}, ref Ref, opts *ExpandOptions) (*Parameter, error) {
-	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -121,12 +89,7 @@ func ResolveParameterWithBase(root interface{}, ref Ref, opts *ExpandOptions) (*
 
 // ResolveResponse resolves response a reference against a context root
 func ResolveResponse(root interface{}, ref Ref) (*Response, error) {
-	return ResolveResponseWithBase(root, ref, nil)
+	resolver, err := defaultSchemaLoader(root, nil, nil)
-}
-
-// ResolveResponseWithBase resolves response a reference against a context root and base path
-func ResolveResponseWithBase(root interface{}, ref Ref, opts *ExpandOptions) (*Response, error) {
-	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -138,70 +101,23 @@ func ResolveResponseWithBase(root interface{}, ref Ref, opts *ExpandOptions) (*R
 	return result, nil
 }
 
-// ResolveItems resolves header and parameter items reference against a context root and base path
-func ResolveItems(root interface{}, ref Ref, opts *ExpandOptions) (*Items, error) {
-	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	result := new(Items)
-	if err := resolver.Resolve(&ref, result); err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-// ResolvePathItem resolves response a path item against a context root and base path
-func ResolvePathItem(root interface{}, ref Ref, opts *ExpandOptions) (*PathItem, error) {
-	resolver, err := defaultSchemaLoader(root, nil, opts, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	result := new(PathItem)
-	if err := resolver.Resolve(&ref, result); err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
 type schemaLoader struct {
 	loadingRef  *Ref
 	startingRef *Ref
 	currentRef  *Ref
 	root        interface{}
-	options     *ExpandOptions
 	cache       ResolutionCache
 	loadDoc     func(string) (json.RawMessage, error)
 }
 
 var idPtr, _ = jsonpointer.New("/id")
+var schemaPtr, _ = jsonpointer.New("/$schema")
 var refPtr, _ = jsonpointer.New("/$ref")
 
-// PathLoader function to use when loading remote refs
+func defaultSchemaLoader(root interface{}, ref *Ref, cache ResolutionCache) (*schemaLoader, error) {
-var PathLoader func(string) (json.RawMessage, error)
-
-func init() {
-	PathLoader = func(path string) (json.RawMessage, error) {
-		data, err := swag.LoadFromFileOrHTTP(path)
-		if err != nil {
-			return nil, err
-		}
-		return json.RawMessage(data), nil
-	}
-}
-
-func defaultSchemaLoader(
-	root interface{}, ref *Ref,
-	expandOptions *ExpandOptions, cache ResolutionCache) (*schemaLoader, error) {
-
 	if cache == nil {
 		cache = resCache
 	}
-	if expandOptions == nil {
-		expandOptions = &ExpandOptions{}
-	}
 
 	var ptr *jsonpointer.Pointer
 	if ref != nil {
@@ -211,16 +127,18 @@ func defaultSchemaLoader(
 	currentRef := nextRef(root, ref, ptr)
 
 	return &schemaLoader{
+		root:        root,
 		loadingRef:  ref,
 		startingRef: ref,
-		currentRef:  currentRef,
-		root:        root,
-		options:     expandOptions,
 		cache:       cache,
 		loadDoc: func(path string) (json.RawMessage, error) {
-			debugLog("fetching document at %q", path)
+			data, err := swag.LoadFromFileOrHTTP(path)
-			return PathLoader(path)
+			if err != nil {
+				return nil, err
+			}
+			return json.RawMessage(data), nil
 		},
+		currentRef: currentRef,
 	}, nil
 }
 
@@ -241,7 +159,6 @@ func nextRef(startingNode interface{}, startingRef *Ref, ptr *jsonpointer.Pointe
 	if startingRef == nil {
 		return nil
 	}
-
 	if ptr == nil {
 		return startingRef
 	}
@@ -267,106 +184,32 @@ func nextRef(startingNode interface{}, startingRef *Ref, ptr *jsonpointer.Pointe
 
 		refRef, _, _ := refPtr.Get(node)
 		if refRef != nil {
-			var rf Ref
+			rf, _ := NewRef(refRef.(string))
-			switch value := refRef.(type) {
-			case string:
-				rf, _ = NewRef(value)
-			}
 			nw, err := ret.Inherits(rf)
 			if err != nil {
 				break
 			}
-			nwURL := nw.GetURL()
-			if nwURL.Scheme == "file" || (nwURL.Scheme == "" && nwURL.Host == "") {
-				nwpt := filepath.ToSlash(nwURL.Path)
-				if filepath.IsAbs(nwpt) {
-					_, err := os.Stat(nwpt)
-					if err != nil {
-						nwURL.Path = filepath.Join(".", nwpt)
-					}
-				}
-			}
-
 			ret = nw
 		}
 
 	}
-
 	return ret
 }
 
-func debugLog(msg string, args ...interface{}) {
-	if Debug {
-		log.Printf(msg, args...)
-	}
-}
-
-func normalizeFileRef(ref *Ref, relativeBase string) *Ref {
-	refURL := ref.GetURL()
-	debugLog("normalizing %s against %s", ref.String(), relativeBase)
-	if strings.HasPrefix(refURL.String(), "#") {
-		return ref
-	}
-
-	if refURL.Scheme == "file" || (refURL.Scheme == "" && refURL.Host == "") {
-		filePath := refURL.Path
-		debugLog("normalizing file path: %s", filePath)
-
-		if !filepath.IsAbs(filepath.FromSlash(filePath)) && len(relativeBase) != 0 {
-			debugLog("joining %s with %s", relativeBase, filePath)
-			if fi, err := os.Stat(filepath.FromSlash(relativeBase)); err == nil {
-				if !fi.IsDir() {
-					relativeBase = path.Dir(relativeBase)
-				}
-			}
-			filePath = filepath.Join(filepath.FromSlash(relativeBase), filepath.FromSlash(filePath))
-		}
-		if !filepath.IsAbs(filepath.FromSlash(filePath)) {
-			pwd, err := os.Getwd()
-			if err == nil {
-				debugLog("joining cwd %s with %s", pwd, filePath)
-				filePath = filepath.Join(pwd, filePath)
-			}
-		}
-
-		debugLog("cleaning %s", filePath)
-		filePath = filepath.Clean(filePath)
-		_, err := os.Stat(filepath.FromSlash(filePath))
-		if err == nil {
-			debugLog("rewriting url to scheme \"\" path %s", filePath)
-			refURL.Scheme = ""
-			refURL.Path = filepath.ToSlash(filePath)
-			debugLog("new url with joined filepath: %s", refURL.String())
-			*ref = MustCreateRef(refURL.String())
-		}
-	}
-
-	return ref
-}
-
 func (r *schemaLoader) resolveRef(currentRef, ref *Ref, node, target interface{}) error {
-
 	tgt := reflect.ValueOf(target)
 	if tgt.Kind() != reflect.Ptr {
 		return fmt.Errorf("resolve ref: target needs to be a pointer")
 	}
 
 	oldRef := currentRef
-
 	if currentRef != nil {
-		debugLog("resolve ref current %s new %s", currentRef.String(), ref.String())
-		nextRef := nextRef(node, ref, currentRef.GetPointer())
-		if nextRef == nil || nextRef.GetURL() == nil {
-			return nil
-		}
 		var err error
-		currentRef, err = currentRef.Inherits(*nextRef)
+		currentRef, err = currentRef.Inherits(*nextRef(node, ref, currentRef.GetPointer()))
-		debugLog("resolved ref current %s", currentRef.String())
 		if err != nil {
 			return err
 		}
 	}
-
 	if currentRef == nil {
 		currentRef = ref
 	}
@@ -402,14 +245,9 @@ func (r *schemaLoader) resolveRef(currentRef, ref *Ref, node, target interface{}
 		return nil
 	}
 
-	relativeBase := ""
+	if refURL.Scheme != "" && refURL.Host != "" {
-	if r.options != nil && r.options.RelativeBase != "" {
+		// most definitely take the red pill
-		relativeBase = r.options.RelativeBase
+		data, _, _, err := r.load(refURL)
-	}
-	normalizeFileRef(currentRef, relativeBase)
-	normalizeFileRef(ref, relativeBase)
-
-	data, _, _, err := r.load(currentRef.GetURL())
 		if err != nil {
 			return err
 		}
@@ -427,29 +265,9 @@ func (r *schemaLoader) resolveRef(currentRef, ref *Ref, node, target interface{}
 		var res interface{}
 		if currentRef.String() != "" {
 			res, _, err = currentRef.GetPointer().Get(data)
-		if err != nil {
-			if strings.HasPrefix(ref.String(), "#") {
-				if r.loadingRef != nil {
-					rr, er := r.loadingRef.Inherits(*ref)
-					if er != nil {
-						return er
-					}
-					refURL = rr.GetURL()
-
-					data, _, _, err = r.load(refURL)
 			if err != nil {
 				return err
 			}
-				} else {
-					data = r.root
-				}
-			}
-
-			res, _, err = ref.GetPointer().Get(data)
-			if err != nil {
-				return err
-			}
-		}
 		} else {
 			res = data
 		}
@@ -458,13 +276,11 @@ func (r *schemaLoader) resolveRef(currentRef, ref *Ref, node, target interface{}
 			return err
 		}
 
-	r.currentRef = currentRef
+	}
-
 	return nil
 }
 
 func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error) {
-	debugLog("loading schema from url: %s", refURL)
 	toFetch := *refURL
 	toFetch.Fragment = ""
 
@@ -483,28 +299,34 @@ func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error)
 
 	return data, toFetch, fromCache, nil
 }
-
 func (r *schemaLoader) Resolve(ref *Ref, target interface{}) error {
-	return r.resolveRef(r.currentRef, ref, r.root, target)
+	if err := r.resolveRef(r.currentRef, ref, r.root, target); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+type specExpander struct {
+	spec     *Swagger
+	resolver *schemaLoader
 }
 
 // ExpandSpec expands the references in a swagger spec
-func ExpandSpec(spec *Swagger, options *ExpandOptions) error {
+func ExpandSpec(spec *Swagger) error {
-	resolver, err := defaultSchemaLoader(spec, nil, options, nil)
+	resolver, err := defaultSchemaLoader(spec, nil, nil)
 	if err != nil {
 		return err
 	}
 
-	if options == nil || !options.SkipSchemas {
+	for key, defintition := range spec.Definitions {
-		for key, definition := range spec.Definitions {
 		var def *Schema
 		var err error
-			if def, err = expandSchema(definition, []string{"#/definitions/" + key}, resolver); err != nil {
+		if def, err = expandSchema(defintition, []string{"#/definitions/" + key}, resolver); err != nil {
 			return err
 		}
 		spec.Definitions[key] = *def
 	}
-	}
 
 	for key, parameter := range spec.Parameters {
 		if err := expandParameter(&parameter, resolver); err != nil {
@@ -534,11 +356,7 @@ func ExpandSpec(spec *Swagger, options *ExpandOptions) error {
 
 // ExpandSchema expands the refs in the schema object
 func ExpandSchema(schema *Schema, root interface{}, cache ResolutionCache) error {
-	return ExpandSchemaWithBasePath(schema, root, cache, nil)
-}
 
-// ExpandSchemaWithBasePath expands the refs in the schema object, base path configured through expand options
-func ExpandSchemaWithBasePath(schema *Schema, root interface{}, cache ResolutionCache, opts *ExpandOptions) error {
 	if schema == nil {
 		return nil
 	}
@@ -549,17 +367,18 @@ func ExpandSchemaWithBasePath(schema *Schema, root interface{}, cache Resolution
 	nrr, _ := NewRef(schema.ID)
 	var rrr *Ref
 	if nrr.String() != "" {
-		switch rt := root.(type) {
+		switch root.(type) {
 		case *Schema:
-			rid, _ := NewRef(rt.ID)
+			rid, _ := NewRef(root.(*Schema).ID)
 			rrr, _ = rid.Inherits(nrr)
 		case *Swagger:
-			rid, _ := NewRef(rt.ID)
+			rid, _ := NewRef(root.(*Swagger).ID)
 			rrr, _ = rid.Inherits(nrr)
 		}
+
 	}
 
-	resolver, err := defaultSchemaLoader(root, rrr, opts, cache)
+	resolver, err := defaultSchemaLoader(root, rrr, cache)
 	if err != nil {
 		return err
 	}
@@ -570,7 +389,7 @@ func ExpandSchemaWithBasePath(schema *Schema, root interface{}, cache Resolution
 	}
 	var s *Schema
 	if s, err = expandSchema(*schema, refs, resolver); err != nil {
-		return err
+		return nil
 	}
 	*schema = *s
 	return nil
@@ -580,17 +399,9 @@ func expandItems(target Schema, parentRefs []string, resolver *schemaLoader) (*S
 	if target.Items != nil {
 		if target.Items.Schema != nil {
 			t, err := expandSchema(*target.Items.Schema, parentRefs, resolver)
-			if err != nil {
-				if target.Items.Schema.ID == "" {
-					target.Items.Schema.ID = target.ID
-					if err != nil {
-						t, err = expandSchema(*target.Items.Schema, parentRefs, resolver)
 			if err != nil {
 				return nil, err
 			}
-					}
-				}
-			}
 			*target.Items.Schema = *t
 		}
 		for i := range target.Items.Schemas {
@@ -604,108 +415,101 @@ func expandItems(target Schema, parentRefs []string, resolver *schemaLoader) (*S
 	return &target, nil
 }
 
-func expandSchema(target Schema, parentRefs []string, resolver *schemaLoader) (*Schema, error) {
+func expandSchema(target Schema, parentRefs []string, resolver *schemaLoader) (schema *Schema, err error) {
+	defer func() {
+		schema = &target
+	}()
 	if target.Ref.String() == "" && target.Ref.IsRoot() {
-		debugLog("skipping expand schema for no ref and root: %v", resolver.root)
+		target = *resolver.root.(*Schema)
-
+		return
-		return resolver.root.(*Schema), nil
 	}
 
 	// t is the new expanded schema
 	var t *Schema
-
 	for target.Ref.String() != "" {
-		if swag.ContainsStringsCI(parentRefs, target.Ref.String()) {
+		// var newTarget Schema
-			return &target, nil
+		pRefs := strings.Join(parentRefs, ",")
+		pRefs += ","
+		if strings.Contains(pRefs, target.Ref.String()+",") {
+			err = nil
+			return
 		}
 
-		if err := resolver.Resolve(&target.Ref, &t); err != nil {
+		if err = resolver.Resolve(&target.Ref, &t); err != nil {
-			return &target, err
+			return
 		}
-
 		parentRefs = append(parentRefs, target.Ref.String())
 		target = *t
 	}
 
-	t, err := expandItems(target, parentRefs, resolver)
+	if t, err = expandItems(target, parentRefs, resolver); err != nil {
-	if err != nil {
+		return
-		return &target, err
 	}
 	target = *t
 
 	for i := range target.AllOf {
-		t, err := expandSchema(target.AllOf[i], parentRefs, resolver)
+		if t, err = expandSchema(target.AllOf[i], parentRefs, resolver); err != nil {
-		if err != nil {
+			return
-			return &target, err
 		}
 		target.AllOf[i] = *t
 	}
 	for i := range target.AnyOf {
-		t, err := expandSchema(target.AnyOf[i], parentRefs, resolver)
+		if t, err = expandSchema(target.AnyOf[i], parentRefs, resolver); err != nil {
-		if err != nil {
+			return
-			return &target, err
 		}
 		target.AnyOf[i] = *t
 	}
 	for i := range target.OneOf {
-		t, err := expandSchema(target.OneOf[i], parentRefs, resolver)
+		if t, err = expandSchema(target.OneOf[i], parentRefs, resolver); err != nil {
-		if err != nil {
+			return
-			return &target, err
 		}
 		target.OneOf[i] = *t
 	}
 	if target.Not != nil {
-		t, err := expandSchema(*target.Not, parentRefs, resolver)
+		if t, err = expandSchema(*target.Not, parentRefs, resolver); err != nil {
-		if err != nil {
+			return
-			return &target, err
 		}
 		*target.Not = *t
 	}
-	for k := range target.Properties {
+	for k, _ := range target.Properties {
-		t, err := expandSchema(target.Properties[k], parentRefs, resolver)
+		if t, err = expandSchema(target.Properties[k], parentRefs, resolver); err != nil {
-		if err != nil {
+			return
-			return &target, err
 		}
 		target.Properties[k] = *t
 	}
 	if target.AdditionalProperties != nil && target.AdditionalProperties.Schema != nil {
-		t, err := expandSchema(*target.AdditionalProperties.Schema, parentRefs, resolver)
+		if t, err = expandSchema(*target.AdditionalProperties.Schema, parentRefs, resolver); err != nil {
-		if err != nil {
+			return
-			return &target, err
 		}
 		*target.AdditionalProperties.Schema = *t
 	}
-	for k := range target.PatternProperties {
+	for k, _ := range target.PatternProperties {
-		t, err := expandSchema(target.PatternProperties[k], parentRefs, resolver)
+		if t, err = expandSchema(target.PatternProperties[k], parentRefs, resolver); err != nil {
-		if err != nil {
+			return
-			return &target, err
 		}
 		target.PatternProperties[k] = *t
 	}
-	for k := range target.Dependencies {
+	for k, _ := range target.Dependencies {
 		if target.Dependencies[k].Schema != nil {
-			t, err := expandSchema(*target.Dependencies[k].Schema, parentRefs, resolver)
+			if t, err = expandSchema(*target.Dependencies[k].Schema, parentRefs, resolver); err != nil {
-			if err != nil {
+				return
-				return &target, err
 			}
 			*target.Dependencies[k].Schema = *t
 		}
 	}
 	if target.AdditionalItems != nil && target.AdditionalItems.Schema != nil {
-		t, err := expandSchema(*target.AdditionalItems.Schema, parentRefs, resolver)
+		if t, err = expandSchema(*target.AdditionalItems.Schema, parentRefs, resolver); err != nil {
-		if err != nil {
+			return
-			return &target, err
 		}
 		*target.AdditionalItems.Schema = *t
 	}
-	for k := range target.Definitions {
+	for k, _ := range target.Definitions {
-		t, err := expandSchema(target.Definitions[k], parentRefs, resolver)
+		if t, err = expandSchema(target.Definitions[k], parentRefs, resolver); err != nil {
-		if err != nil {
+			return
-			return &target, err
 		}
 		target.Definitions[k] = *t
 	}
-	return &target, nil
+	return
 }
 
 func expandPathItem(pathItem *PathItem, resolver *schemaLoader) error {
@@ -778,26 +582,23 @@ func expandResponse(response *Response, resolver *schemaLoader) error {
 		return nil
 	}
 
-	var parentRefs []string
 	if response.Ref.String() != "" {
-		parentRefs = append(parentRefs, response.Ref.String())
 		if err := resolver.Resolve(&response.Ref, response); err != nil {
 			return err
 		}
 	}
 
-	if !resolver.options.SkipSchemas && response.Schema != nil {
+	if response.Schema != nil {
-		parentRefs = append(parentRefs, response.Schema.Ref.String())
+		parentRefs := []string{response.Schema.Ref.String()}
-		debugLog("response ref: %s", response.Schema.Ref)
 		if err := resolver.Resolve(&response.Schema.Ref, &response.Schema); err != nil {
 			return err
 		}
-		s, err := expandSchema(*response.Schema, parentRefs, resolver)
+		if s, err := expandSchema(*response.Schema, parentRefs, resolver); err != nil {
-		if err != nil {
 			return err
-		}
+		} else {
 			*response.Schema = *s
 		}
+	}
 	return nil
 }
 
@@ -805,24 +606,21 @@ func expandParameter(parameter *Parameter, resolver *schemaLoader) error {
 	if parameter == nil {
 		return nil
 	}
-
-	var parentRefs []string
 	if parameter.Ref.String() != "" {
-		parentRefs = append(parentRefs, parameter.Ref.String())
 		if err := resolver.Resolve(&parameter.Ref, parameter); err != nil {
 			return err
 		}
 	}
-	if !resolver.options.SkipSchemas && parameter.Schema != nil {
+	if parameter.Schema != nil {
-		parentRefs = append(parentRefs, parameter.Schema.Ref.String())
+		parentRefs := []string{parameter.Schema.Ref.String()}
 		if err := resolver.Resolve(&parameter.Schema.Ref, &parameter.Schema); err != nil {
 			return err
 		}
-		s, err := expandSchema(*parameter.Schema, parentRefs, resolver)
+		if s, err := expandSchema(*parameter.Schema, parentRefs, resolver); err != nil {
-		if err != nil {
 			return err
-		}
+		} else {
 			*parameter.Schema = *s
 		}
+	}
 	return nil
 }

vendor/github.com/go-openapi/spec/header.go

@@ -16,9 +16,7 @@ package spec
 
 import (
 	"encoding/json"
-	"strings"
 
-	"github.com/go-openapi/jsonpointer"
 	"github.com/go-openapi/swag"
 )
 
@@ -32,7 +30,6 @@ type HeaderProps struct {
 type Header struct {
 	CommonValidations
 	SimpleSchema
-	VendorExtensible
 	HeaderProps
 }
 
@@ -161,35 +158,8 @@ func (h *Header) UnmarshalJSON(data []byte) error {
 	if err := json.Unmarshal(data, &h.SimpleSchema); err != nil {
 		return err
 	}
-	if err := json.Unmarshal(data, &h.VendorExtensible); err != nil {
-		return err
-	}
 	if err := json.Unmarshal(data, &h.HeaderProps); err != nil {
 		return err
 	}
 	return nil
 }
-
-// JSONLookup look up a value by the json property name
-func (p Header) JSONLookup(token string) (interface{}, error) {
-	if ex, ok := p.Extensions[token]; ok {
-		return &ex, nil
-	}
-
-	r, _, err := jsonpointer.GetForToken(p.CommonValidations, token)
-	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
-		return nil, err
-	}
-	if r != nil {
-		return r, nil
-	}
-	r, _, err = jsonpointer.GetForToken(p.SimpleSchema, token)
-	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
-		return nil, err
-	}
-	if r != nil {
-		return r, nil
-	}
-	r, _, err = jsonpointer.GetForToken(p.HeaderProps, token)
-	return r, err
-}

vendor/github.com/go-openapi/spec/items.go

@@ -16,9 +16,7 @@ package spec
 
 import (
 	"encoding/json"
-	"strings"
 
-	"github.com/go-openapi/jsonpointer"
 	"github.com/go-openapi/swag"
 )
 
@@ -199,20 +197,3 @@ func (i Items) MarshalJSON() ([]byte, error) {
 	}
 	return swag.ConcatJSON(b3, b1, b2), nil
 }
-
-// JSONLookup look up a value by the json property name
-func (p Items) JSONLookup(token string) (interface{}, error) {
-	if token == "$ref" {
-		return &p.Ref, nil
-	}
-
-	r, _, err := jsonpointer.GetForToken(p.CommonValidations, token)
-	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
-		return nil, err
-	}
-	if r != nil {
-		return r, nil
-	}
-	r, _, err = jsonpointer.GetForToken(p.SimpleSchema, token)
-	return r, err
-}

vendor/github.com/go-openapi/spec/parameter.go

@@ -16,7 +16,6 @@ package spec
 
 import (
 	"encoding/json"
-	"strings"
 
 	"github.com/go-openapi/jsonpointer"
 	"github.com/go-openapi/swag"
@@ -101,16 +100,15 @@ func (p Parameter) JSONLookup(token string) (interface{}, error) {
 	if token == "$ref" {
 		return &p.Ref, nil
 	}
-
 	r, _, err := jsonpointer.GetForToken(p.CommonValidations, token)
-	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
+	if err != nil {
 		return nil, err
 	}
 	if r != nil {
 		return r, nil
 	}
 	r, _, err = jsonpointer.GetForToken(p.SimpleSchema, token)
-	if err != nil && !strings.HasPrefix(err.Error(), "object has no field") {
+	if err != nil {
 		return nil, err
 	}
 	if r != nil {

vendor/github.com/go-openapi/spec/ref.go

@@ -55,7 +55,7 @@ func (r *Ref) RemoteURI() string {
 }
 
 // IsValidURI returns true when the url the ref points to can be found
-func (r *Ref) IsValidURI(basepaths ...string) bool {
+func (r *Ref) IsValidURI() bool {
 	if r.String() == "" {
 		return true
 	}
@@ -81,18 +81,14 @@ func (r *Ref) IsValidURI(basepaths ...string) bool {
 	// check for local file
 	pth := v
 	if r.HasURLPathOnly {
-		base := "."
+		p, e := filepath.Abs(pth)
-		if len(basepaths) > 0 {
-			base = filepath.Dir(filepath.Join(basepaths...))
-		}
-		p, e := filepath.Abs(filepath.ToSlash(filepath.Join(base, pth)))
 		if e != nil {
 			return false
 		}
 		pth = p
 	}
 
-	fi, err := os.Stat(filepath.ToSlash(pth))
+	fi, err := os.Stat(pth)
 	if err != nil {
 		return false
 	}

vendor/github.com/go-openapi/spec/response.go

@@ -17,7 +17,6 @@ package spec
 import (
 	"encoding/json"
 
-	"github.com/go-openapi/jsonpointer"
 	"github.com/go-openapi/swag"
 )
 
@@ -37,15 +36,6 @@ type Response struct {
 	ResponseProps
 }
 
-// JSONLookup look up a value by the json property name
-func (p Response) JSONLookup(token string) (interface{}, error) {
-	if token == "$ref" {
-		return &p.Ref, nil
-	}
-	r, _, err := jsonpointer.GetForToken(p.ResponseProps, token)
-	return r, err
-}
-
 // UnmarshalJSON hydrates this items instance with the data from JSON
 func (r *Response) UnmarshalJSON(data []byte) error {
 	if err := json.Unmarshal(data, &r.ResponseProps); err != nil {

vendor/github.com/go-openapi/spec/responses.go

@@ -51,7 +51,7 @@ func (r Responses) JSONLookup(token string) (interface{}, error) {
 	}
 	if i, err := strconv.Atoi(token); err == nil {
 		if scr, ok := r.StatusCodeResponses[i]; ok {
-			return scr, nil
+			return &scr, nil
 		}
 	}
 	return nil, fmt.Errorf("object has no field %q", token)

vendor/github.com/go-openapi/spec/schema.go

@@ -269,7 +269,7 @@ func (s Schema) JSONLookup(token string) (interface{}, error) {
 	}
 
 	r, _, err := jsonpointer.GetForToken(s.SchemaProps, token)
-	if r != nil || (err != nil && !strings.HasPrefix(err.Error(), "object has no field")) {
+	if r != nil || err != nil {
 		return r, err
 	}
 	r, _, err = jsonpointer.GetForToken(s.SwaggerSchemaProps, token)

vendor/github.com/go-openapi/spec/spec.go

@@ -16,8 +16,6 @@ package spec
 
 import "encoding/json"
 
-//go:generate curl -L --progress -o ./schemas/v2/schema.json http://swagger.io/v2/schema.json
-//go:generate curl -L --progress  -o ./schemas/jsonschema-draft-04.json http://json-schema.org/draft-04/schema
 //go:generate go-bindata -pkg=spec -prefix=./schemas -ignore=.*\.md ./schemas/...
 //go:generate perl -pi -e s,Json,JSON,g bindata.go
 
@@ -29,14 +27,9 @@ const (
 )
 
 var (
-	jsonSchema    *Schema
-	swaggerSchema *Schema
-)
-
-func init() {
 	jsonSchema    = MustLoadJSONSchemaDraft04()
 	swaggerSchema = MustLoadSwagger20Schema()
-}
+)
 
 // MustLoadJSONSchemaDraft04 panics when Swagger20Schema returns an error
 func MustLoadJSONSchemaDraft04() *Schema {

vendor/github.com/go-openapi/swag/convert.go

@@ -159,7 +159,7 @@ func FormatInt16(value int16) string {
 
 // FormatInt32 turns an int32 into a string
 func FormatInt32(value int32) string {
-	return strconv.Itoa(int(value))
+	return strconv.FormatInt(int64(value), 10)
 }
 
 // FormatInt64 turns an int64 into a string

vendor/github.com/go-openapi/swag/json.go

@@ -17,7 +17,6 @@ package swag
 import (
 	"bytes"
 	"encoding/json"
-	"log"
 	"reflect"
 	"strings"
 	"sync"
@@ -111,40 +110,28 @@ func ConcatJSON(blobs ...[]byte) []byte {
 
 		if len(b) < 3 { // yep empty but also the last one, so closing this thing
 			if i == last && a > 0 {
-				if err := buf.WriteByte(closing); err != nil {
+				buf.WriteByte(closing)
-					log.Println(err)
-				}
 			}
 			continue
 		}
 
 		idx = 0
 		if a > 0 { // we need to join with a comma for everything beyond the first non-empty item
-			if err := buf.WriteByte(comma); err != nil {
+			buf.WriteByte(comma)
-				log.Println(err)
-			}
 			idx = 1 // this is not the first or the last so we want to drop the leading bracket
 		}
 
 		if i != last { // not the last one, strip brackets
-			if _, err := buf.Write(b[idx : len(b)-1]); err != nil {
+			buf.Write(b[idx : len(b)-1])
-				log.Println(err)
-			}
 		} else { // last one, strip only the leading bracket
-			if _, err := buf.Write(b[idx:]); err != nil {
+			buf.Write(b[idx:])
-				log.Println(err)
-			}
 		}
 		a++
 	}
 	// somehow it ended up being empty, so provide a default value
 	if buf.Len() == 0 {
-		if err := buf.WriteByte(opening); err != nil {
+		buf.WriteByte(opening)
-			log.Println(err)
+		buf.WriteByte(closing)
-		}
-		if err := buf.WriteByte(closing); err != nil {
-			log.Println(err)
-		}
 	}
 	return buf.Bytes()
 }
@@ -152,23 +139,15 @@ func ConcatJSON(blobs ...[]byte) []byte {
 // ToDynamicJSON turns an object into a properly JSON typed structure
 func ToDynamicJSON(data interface{}) interface{} {
 	// TODO: convert straight to a json typed map (mergo + iterate?)
-	b, err := json.Marshal(data)
+	b, _ := json.Marshal(data)
-	if err != nil {
-		log.Println(err)
-	}
 	var res interface{}
-	if err := json.Unmarshal(b, &res); err != nil {
+	json.Unmarshal(b, &res)
-		log.Println(err)
-	}
 	return res
 }
 
 // FromDynamicJSON turns an object into a properly JSON typed structure
 func FromDynamicJSON(data, target interface{}) error {
-	b, err := json.Marshal(data)
+	b, _ := json.Marshal(data)
-	if err != nil {
-		log.Println(err)
-	}
 	return json.Unmarshal(b, target)
 }
 

vendor/github.com/go-openapi/swag/loading.go

@@ -17,25 +17,13 @@ package swag
 import (
 	"fmt"
 	"io/ioutil"
-	"log"
 	"net/http"
-	"path/filepath"
 	"strings"
-	"time"
 )
 
-// LoadHTTPTimeout the default timeout for load requests
-var LoadHTTPTimeout = 30 * time.Second
-
 // LoadFromFileOrHTTP loads the bytes from a file or a remote http server based on the path passed in
 func LoadFromFileOrHTTP(path string) ([]byte, error) {
-	return LoadStrategy(path, ioutil.ReadFile, loadHTTPBytes(LoadHTTPTimeout))(path)
+	return LoadStrategy(path, ioutil.ReadFile, loadHTTPBytes)(path)
-}
-
-// LoadFromFileOrHTTPWithTimeout loads the bytes from a file or a remote http server based on the path passed in
-// timeout arg allows for per request overriding of the request timeout
-func LoadFromFileOrHTTPWithTimeout(path string, timeout time.Duration) ([]byte, error) {
-	return LoadStrategy(path, ioutil.ReadFile, loadHTTPBytes(timeout))(path)
 }
 
 // LoadStrategy returns a loader function for a given path or uri
@@ -43,32 +31,19 @@ func LoadStrategy(path string, local, remote func(string) ([]byte, error)) func(
 	if strings.HasPrefix(path, "http") {
 		return remote
 	}
-	return func(pth string) ([]byte, error) { return local(filepath.FromSlash(pth)) }
+	return local
 }
 
-func loadHTTPBytes(timeout time.Duration) func(path string) ([]byte, error) {
+func loadHTTPBytes(path string) ([]byte, error) {
-	return func(path string) ([]byte, error) {
+	resp, err := http.Get(path)
-		client := &http.Client{Timeout: timeout}
-		req, err := http.NewRequest("GET", path, nil)
-		if err != nil {
-			return nil, err
-		}
-		resp, err := client.Do(req)
-		defer func() {
-			if resp != nil {
-				if e := resp.Body.Close(); e != nil {
-					log.Println(e)
-				}
-			}
-		}()
 	if err != nil {
 		return nil, err
 	}
+	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
 		return nil, fmt.Errorf("could not access document at %q [%s] ", path, resp.Status)
 	}
 
 	return ioutil.ReadAll(resp.Body)
-	}
 }

vendor/github.com/go-openapi/swag/util.go

@@ -22,9 +22,8 @@ import (
 	"strings"
 )
 
-// Taken from https://github.com/golang/lint/blob/3390df4df2787994aea98de825b964ac7944b817/lint.go#L732-L769
+// Taken from https://github.com/golang/lint/blob/1fab560e16097e5b69afb66eb93aab843ef77845/lint.go#L663-L698
 var commonInitialisms = map[string]bool{
-	"ACL":   true,
 	"API":   true,
 	"ASCII": true,
 	"CPU":   true,
@@ -45,21 +44,19 @@ var commonInitialisms = map[string]bool{
 	"RPC":   true,
 	"SLA":   true,
 	"SMTP":  true,
-	"SQL":   true,
 	"SSH":   true,
 	"TCP":   true,
 	"TLS":   true,
 	"TTL":   true,
 	"UDP":   true,
-	"UI":    true,
-	"UID":   true,
 	"UUID":  true,
+	"UID":   true,
+	"UI":    true,
 	"URI":   true,
 	"URL":   true,
 	"UTF8":  true,
 	"VM":    true,
 	"XML":   true,
-	"XMPP":  true,
 	"XSRF":  true,
 	"XSS":   true,
 }
@@ -249,9 +246,6 @@ func ToJSONName(name string) string {
 // ToVarName camelcases a name which can be underscored or pascal cased
 func ToVarName(name string) string {
 	res := ToGoName(name)
-	if _, ok := commonInitialisms[res]; ok {
-		return lower(res)
-	}
 	if len(res) <= 1 {
 		return lower(res)
 	}

vendor/github.com/google/gofuzz/fuzz.go

@@ -129,7 +129,7 @@ func (f *Fuzzer) genElementCount() int {
 	if f.minElements == f.maxElements {
 		return f.minElements
 	}
-	return f.minElements + f.r.Intn(f.maxElements-f.minElements+1)
+	return f.minElements + f.r.Intn(f.maxElements-f.minElements)
 }
 
 func (f *Fuzzer) genShouldFill() bool {
@@ -229,19 +229,12 @@ func (f *Fuzzer) doFuzz(v reflect.Value, flags uint64) {
 			return
 		}
 		v.Set(reflect.Zero(v.Type()))
-	case reflect.Array:
-		if f.genShouldFill() {
-			n := v.Len()
-			for i := 0; i < n; i++ {
-				f.doFuzz(v.Index(i), 0)
-			}
-			return
-		}
-		v.Set(reflect.Zero(v.Type()))
 	case reflect.Struct:
 		for i := 0; i < v.NumField(); i++ {
 			f.doFuzz(v.Field(i), 0)
 		}
+	case reflect.Array:
+		fallthrough
 	case reflect.Chan:
 		fallthrough
 	case reflect.Func:

vendor/github.com/googleapis/gax-go/LICENSE

@@ -0,0 +1,27 @@
+Copyright 2016, Google Inc.
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/googleapis/gax-go/call_option.go

@@ -0,0 +1,149 @@
+// Copyright 2016, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package gax
+
+import (
+	"math/rand"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+)
+
+// CallOption is an option used by Invoke to control behaviors of RPC calls.
+// CallOption works by modifying relevant fields of CallSettings.
+type CallOption interface {
+	// Resolve applies the option by modifying cs.
+	Resolve(cs *CallSettings)
+}
+
+// Retryer is used by Invoke to determine retry behavior.
+type Retryer interface {
+	// Retry reports whether a request should be retriedand how long to pause before retrying
+	// if the previous attempt returned with err. Invoke never calls Retry with nil error.
+	Retry(err error) (pause time.Duration, shouldRetry bool)
+}
+
+type retryerOption func() Retryer
+
+func (o retryerOption) Resolve(s *CallSettings) {
+	s.Retry = o
+}
+
+// WithRetry sets CallSettings.Retry to fn.
+func WithRetry(fn func() Retryer) CallOption {
+	return retryerOption(fn)
+}
+
+// OnCodes returns a Retryer that retries if and only if
+// the previous attempt returns a GRPC error whose error code is stored in cc.
+// Pause times between retries are specified by bo.
+//
+// bo is only used for its parameters; each Retryer has its own copy.
+func OnCodes(cc []codes.Code, bo Backoff) Retryer {
+	return &boRetryer{
+		backoff: bo,
+		codes:   append([]codes.Code(nil), cc...),
+	}
+}
+
+type boRetryer struct {
+	backoff Backoff
+	codes   []codes.Code
+}
+
+func (r *boRetryer) Retry(err error) (time.Duration, bool) {
+	c := grpc.Code(err)
+	for _, rc := range r.codes {
+		if c == rc {
+			return r.backoff.Pause(), true
+		}
+	}
+	return 0, false
+}
+
+// Backoff implements exponential backoff.
+// The wait time between retries is a random value between 0 and the "retry envelope".
+// The envelope starts at Initial and increases by the factor of Multiplier every retry,
+// but is capped at Max.
+type Backoff struct {
+	// Initial is the initial value of the retry envelope, defaults to 1 second.
+	Initial time.Duration
+
+	// Max is the maximum value of the retry envelope, defaults to 30 seconds.
+	Max time.Duration
+
+	// Multiplier is the factor by which the retry envelope increases.
+	// It should be greater than 1 and defaults to 2.
+	Multiplier float64
+
+	// cur is the current retry envelope
+	cur time.Duration
+}
+
+func (bo *Backoff) Pause() time.Duration {
+	if bo.Initial == 0 {
+		bo.Initial = time.Second
+	}
+	if bo.cur == 0 {
+		bo.cur = bo.Initial
+	}
+	if bo.Max == 0 {
+		bo.Max = 30 * time.Second
+	}
+	if bo.Multiplier < 1 {
+		bo.Multiplier = 2
+	}
+	d := time.Duration(rand.Int63n(int64(bo.cur)))
+	bo.cur = time.Duration(float64(bo.cur) * bo.Multiplier)
+	if bo.cur > bo.Max {
+		bo.cur = bo.Max
+	}
+	return d
+}
+
+type grpcOpt []grpc.CallOption
+
+func (o grpcOpt) Resolve(s *CallSettings) {
+	s.GRPC = o
+}
+
+func WithGRPCOptions(opt ...grpc.CallOption) CallOption {
+	return grpcOpt(append([]grpc.CallOption(nil), opt...))
+}
+
+type CallSettings struct {
+	// Retry returns a Retryer to be used to control retry logic of a method call.
+	// If Retry is nil or the returned Retryer is nil, the call will not be retried.
+	Retry func() Retryer
+
+	// CallOptions to be forwarded to GRPC.
+	GRPC []grpc.CallOption
+}

vendor/github.com/googleapis/gax-go/gax.go

@@ -0,0 +1,40 @@
+// Copyright 2016, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Package gax contains a set of modules which aid the development of APIs
+// for clients and servers based on gRPC and Google API conventions.
+//
+// Application code will rarely need to use this library directly.
+// However, code generated automatically from API definition files can use it
+// to simplify code generation and to provide more convenient and idiomatic API surfaces.
+//
+// This project is currently experimental and not supported.
+package gax
+
+const Version = "0.1.0"

vendor/github.com/googleapis/gax-go/header.go

@@ -0,0 +1,24 @@
+package gax
+
+import "bytes"
+
+// XGoogHeader is for use by the Google Cloud Libraries only.
+//
+// XGoogHeader formats key-value pairs.
+// The resulting string is suitable for x-goog-api-client header.
+func XGoogHeader(keyval ...string) string {
+	if len(keyval) == 0 {
+		return ""
+	}
+	if len(keyval)%2 != 0 {
+		panic("gax.Header: odd argument count")
+	}
+	var buf bytes.Buffer
+	for i := 0; i < len(keyval); i += 2 {
+		buf.WriteByte(' ')
+		buf.WriteString(keyval[i])
+		buf.WriteByte('/')
+		buf.WriteString(keyval[i+1])
+	}
+	return buf.String()[1:]
+}

vendor/github.com/googleapis/gax-go/invoke.go

@@ -0,0 +1,90 @@
+// Copyright 2016, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package gax
+
+import (
+	"time"
+
+	"golang.org/x/net/context"
+)
+
+// A user defined call stub.
+type APICall func(context.Context, CallSettings) error
+
+// Invoke calls the given APICall,
+// performing retries as specified by opts, if any.
+func Invoke(ctx context.Context, call APICall, opts ...CallOption) error {
+	var settings CallSettings
+	for _, opt := range opts {
+		opt.Resolve(&settings)
+	}
+	return invoke(ctx, call, settings, Sleep)
+}
+
+// Sleep is similar to time.Sleep, but it can be interrupted by ctx.Done() closing.
+// If interrupted, Sleep returns ctx.Err().
+func Sleep(ctx context.Context, d time.Duration) error {
+	t := time.NewTimer(d)
+	select {
+	case <-ctx.Done():
+		t.Stop()
+		return ctx.Err()
+	case <-t.C:
+		return nil
+	}
+}
+
+type sleeper func(ctx context.Context, d time.Duration) error
+
+// invoke implements Invoke, taking an additional sleeper argument for testing.
+func invoke(ctx context.Context, call APICall, settings CallSettings, sp sleeper) error {
+	var retryer Retryer
+	for {
+		err := call(ctx, settings)
+		if err == nil {
+			return nil
+		}
+		if settings.Retry == nil {
+			return err
+		}
+		if retryer == nil {
+			if r := settings.Retry(); r != nil {
+				retryer = r
+			} else {
+				return err
+			}
+		}
+		if d, ok := retryer.Retry(err); !ok {
+			return err
+		} else if err = sp(ctx, d); err != nil {
+			return err
+		}
+	}
+}

vendor/github.com/googleapis/gax-go/path_template.go

@@ -0,0 +1,176 @@
+// Copyright 2016, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package gax
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+type matcher interface {
+	match([]string) (int, error)
+	String() string
+}
+
+type segment struct {
+	matcher
+	name string
+}
+
+type labelMatcher string
+
+func (ls labelMatcher) match(segments []string) (int, error) {
+	if len(segments) == 0 {
+		return 0, fmt.Errorf("expected %s but no more segments found", ls)
+	}
+	if segments[0] != string(ls) {
+		return 0, fmt.Errorf("expected %s but got %s", ls, segments[0])
+	}
+	return 1, nil
+}
+
+func (ls labelMatcher) String() string {
+	return string(ls)
+}
+
+type wildcardMatcher int
+
+func (wm wildcardMatcher) match(segments []string) (int, error) {
+	if len(segments) == 0 {
+		return 0, errors.New("no more segments found")
+	}
+	return 1, nil
+}
+
+func (wm wildcardMatcher) String() string {
+	return "*"
+}
+
+type pathWildcardMatcher int
+
+func (pwm pathWildcardMatcher) match(segments []string) (int, error) {
+	length := len(segments) - int(pwm)
+	if length <= 0 {
+		return 0, errors.New("not sufficient segments are supplied for path wildcard")
+	}
+	return length, nil
+}
+
+func (pwm pathWildcardMatcher) String() string {
+	return "**"
+}
+
+type ParseError struct {
+	Pos      int
+	Template string
+	Message  string
+}
+
+func (pe ParseError) Error() string {
+	return fmt.Sprintf("at %d of template '%s', %s", pe.Pos, pe.Template, pe.Message)
+}
+
+// PathTemplate manages the template to build and match with paths used
+// by API services. It holds a template and variable names in it, and
+// it can extract matched patterns from a path string or build a path
+// string from a binding.
+//
+// See http.proto in github.com/googleapis/googleapis/ for the details of
+// the template syntax.
+type PathTemplate struct {
+	segments []segment
+}
+
+// NewPathTemplate parses a path template, and returns a PathTemplate
+// instance if successful.
+func NewPathTemplate(template string) (*PathTemplate, error) {
+	return parsePathTemplate(template)
+}
+
+// MustCompilePathTemplate is like NewPathTemplate but panics if the
+// expression cannot be parsed. It simplifies safe initialization of
+// global variables holding compiled regular expressions.
+func MustCompilePathTemplate(template string) *PathTemplate {
+	pt, err := NewPathTemplate(template)
+	if err != nil {
+		panic(err)
+	}
+	return pt
+}
+
+// Match attempts to match the given path with the template, and returns
+// the mapping of the variable name to the matched pattern string.
+func (pt *PathTemplate) Match(path string) (map[string]string, error) {
+	paths := strings.Split(path, "/")
+	values := map[string]string{}
+	for _, segment := range pt.segments {
+		length, err := segment.match(paths)
+		if err != nil {
+			return nil, err
+		}
+		if segment.name != "" {
+			value := strings.Join(paths[:length], "/")
+			if oldValue, ok := values[segment.name]; ok {
+				values[segment.name] = oldValue + "/" + value
+			} else {
+				values[segment.name] = value
+			}
+		}
+		paths = paths[length:]
+	}
+	if len(paths) != 0 {
+		return nil, fmt.Errorf("Trailing path %s remains after the matching", strings.Join(paths, "/"))
+	}
+	return values, nil
+}
+
+// Render creates a path string from its template and the binding from
+// the variable name to the value.
+func (pt *PathTemplate) Render(binding map[string]string) (string, error) {
+	result := make([]string, 0, len(pt.segments))
+	var lastVariableName string
+	for _, segment := range pt.segments {
+		name := segment.name
+		if lastVariableName != "" && name == lastVariableName {
+			continue
+		}
+		lastVariableName = name
+		if name == "" {
+			result = append(result, segment.String())
+		} else if value, ok := binding[name]; ok {
+			result = append(result, value)
+		} else {
+			return "", fmt.Errorf("%s is not found", name)
+		}
+	}
+	built := strings.Join(result, "/")
+	return built, nil
+}

vendor/github.com/googleapis/gax-go/path_template_parser.go

@@ -0,0 +1,227 @@
+// Copyright 2016, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package gax
+
+import (
+	"fmt"
+	"io"
+	"strings"
+)
+
+// This parser follows the syntax of path templates, from
+// https://github.com/googleapis/googleapis/blob/master/google/api/http.proto.
+// The differences are that there is no custom verb, we allow the initial slash
+// to be absent, and that we are not strict as
+// https://tools.ietf.org/html/rfc6570 about the characters in identifiers and
+// literals.
+
+type pathTemplateParser struct {
+	r                *strings.Reader
+	runeCount        int             // the number of the current rune in the original string
+	nextVar          int             // the number to use for the next unnamed variable
+	seenName         map[string]bool // names we've seen already
+	seenPathWildcard bool            // have we seen "**" already?
+}
+
+func parsePathTemplate(template string) (pt *PathTemplate, err error) {
+	p := &pathTemplateParser{
+		r:        strings.NewReader(template),
+		seenName: map[string]bool{},
+	}
+
+	// Handle panics with strings like errors.
+	// See pathTemplateParser.error, below.
+	defer func() {
+		if x := recover(); x != nil {
+			errmsg, ok := x.(errString)
+			if !ok {
+				panic(x)
+			}
+			pt = nil
+			err = ParseError{p.runeCount, template, string(errmsg)}
+		}
+	}()
+
+	segs := p.template()
+	// If there is a path wildcard, set its length. We can't do this
+	// until we know how many segments we've got all together.
+	for i, seg := range segs {
+		if _, ok := seg.matcher.(pathWildcardMatcher); ok {
+			segs[i].matcher = pathWildcardMatcher(len(segs) - i - 1)
+			break
+		}
+	}
+	return &PathTemplate{segments: segs}, nil
+
+}
+
+// Used to indicate errors "thrown" by this parser. We don't use string because
+// many parts of the standard library panic with strings.
+type errString string
+
+// Terminates parsing immediately with an error.
+func (p *pathTemplateParser) error(msg string) {
+	panic(errString(msg))
+}
+
+// Template = [ "/" ] Segments
+func (p *pathTemplateParser) template() []segment {
+	var segs []segment
+	if p.consume('/') {
+		// Initial '/' needs an initial empty matcher.
+		segs = append(segs, segment{matcher: labelMatcher("")})
+	}
+	return append(segs, p.segments("")...)
+}
+
+// Segments = Segment { "/" Segment }
+func (p *pathTemplateParser) segments(name string) []segment {
+	var segs []segment
+	for {
+		subsegs := p.segment(name)
+		segs = append(segs, subsegs...)
+		if !p.consume('/') {
+			break
+		}
+	}
+	return segs
+}
+
+// Segment  = "*" | "**" | LITERAL | Variable
+func (p *pathTemplateParser) segment(name string) []segment {
+	if p.consume('*') {
+		if name == "" {
+			name = fmt.Sprintf("$%d", p.nextVar)
+			p.nextVar++
+		}
+		if p.consume('*') {
+			if p.seenPathWildcard {
+				p.error("multiple '**' disallowed")
+			}
+			p.seenPathWildcard = true
+			// We'll change 0 to the right number at the end.
+			return []segment{{name: name, matcher: pathWildcardMatcher(0)}}
+		}
+		return []segment{{name: name, matcher: wildcardMatcher(0)}}
+	}
+	if p.consume('{') {
+		if name != "" {
+			p.error("recursive named bindings are not allowed")
+		}
+		return p.variable()
+	}
+	return []segment{{name: name, matcher: labelMatcher(p.literal())}}
+}
+
+// Variable = "{" FieldPath [ "=" Segments ] "}"
+// "{" is already consumed.
+func (p *pathTemplateParser) variable() []segment {
+	// Simplification: treat FieldPath as LITERAL, instead of IDENT { '.' IDENT }
+	name := p.literal()
+	if p.seenName[name] {
+		p.error(name + " appears multiple times")
+	}
+	p.seenName[name] = true
+	var segs []segment
+	if p.consume('=') {
+		segs = p.segments(name)
+	} else {
+		// "{var}" is equivalent to "{var=*}"
+		segs = []segment{{name: name, matcher: wildcardMatcher(0)}}
+	}
+	if !p.consume('}') {
+		p.error("expected '}'")
+	}
+	return segs
+}
+
+// A literal is any sequence of characters other than a few special ones.
+// The list of stop characters is not quite the same as in the template RFC.
+func (p *pathTemplateParser) literal() string {
+	lit := p.consumeUntil("/*}{=")
+	if lit == "" {
+		p.error("empty literal")
+	}
+	return lit
+}
+
+// Read runes until EOF or one of the runes in stopRunes is encountered.
+// If the latter, unread the stop rune. Return the accumulated runes as a string.
+func (p *pathTemplateParser) consumeUntil(stopRunes string) string {
+	var runes []rune
+	for {
+		r, ok := p.readRune()
+		if !ok {
+			break
+		}
+		if strings.IndexRune(stopRunes, r) >= 0 {
+			p.unreadRune()
+			break
+		}
+		runes = append(runes, r)
+	}
+	return string(runes)
+}
+
+// If the next rune is r, consume it and return true.
+// Otherwise, leave the input unchanged and return false.
+func (p *pathTemplateParser) consume(r rune) bool {
+	rr, ok := p.readRune()
+	if !ok {
+		return false
+	}
+	if r == rr {
+		return true
+	}
+	p.unreadRune()
+	return false
+}
+
+// Read the next rune from the input. Return it.
+// The second return value is false at EOF.
+func (p *pathTemplateParser) readRune() (rune, bool) {
+	r, _, err := p.r.ReadRune()
+	if err == io.EOF {
+		return r, false
+	}
+	if err != nil {
+		p.error(err.Error())
+	}
+	p.runeCount++
+	return r, true
+}
+
+// Put the last rune that was read back on the input.
+func (p *pathTemplateParser) unreadRune() {
+	if err := p.r.UnreadRune(); err != nil {
+		p.error(err.Error())
+	}
+	p.runeCount--
+}

vendor/github.com/mailru/easyjson/jlexer/lexer.go

@@ -5,7 +5,6 @@
 package jlexer
 
 import (
-	"encoding/base64"
 	"fmt"
 	"io"
 	"reflect"
@@ -506,7 +505,7 @@ func (r *Lexer) SkipRecursive() {
 				return
 			}
 		case c == '\\' && inQuotes:
-			wasEscape = !wasEscape
+			wasEscape = true
 			continue
 		case c == '"' && inQuotes:
 			inQuotes = wasEscape
@@ -516,11 +515,7 @@ func (r *Lexer) SkipRecursive() {
 		wasEscape = false
 	}
 	r.pos = len(r.Data)
-	r.err = &LexerError{
+	r.err = io.EOF
-		Reason: "EOF reached while skipping array/object or token",
-		Offset: r.pos,
-		Data:   string(r.Data[r.pos:]),
-	}
 }
 
 // Raw fetches the next item recursively as a data slice
@@ -532,34 +527,6 @@ func (r *Lexer) Raw() []byte {
 	return r.Data[r.start:r.pos]
 }
 
-// IsStart returns whether the lexer is positioned at the start
-// of an input string.
-func (r *Lexer) IsStart() bool {
-	return r.pos == 0
-}
-
-// Consumed reads all remaining bytes from the input, publishing an error if
-// there is anything but whitespace remaining.
-func (r *Lexer) Consumed() {
-	if r.pos > len(r.Data) {
-		return
-	}
-
-	for _, c := range r.Data[r.pos:] {
-		if c != ' ' && c != '\t' && c != '\r' && c != '\n' {
-			r.err = &LexerError{
-				Reason: "invalid character '" + string(c) + "' after top-level value",
-				Offset: r.pos,
-				Data:   string(r.Data[r.pos:]),
-			}
-			return
-		}
-
-		r.pos++
-		r.start++
-	}
-}
-
 // UnsafeString returns the string value if the token is a string literal.
 //
 // Warning: returned string may point to the input buffer, so the string should not outlive
@@ -593,28 +560,6 @@ func (r *Lexer) String() string {
 	return ret
 }
 
-// Bytes reads a string literal and base64 decodes it into a byte slice.
-func (r *Lexer) Bytes() []byte {
-	if r.token.kind == tokenUndef && r.Ok() {
-		r.fetchToken()
-	}
-	if !r.Ok() || r.token.kind != tokenString {
-		r.errInvalidToken("string")
-		return nil
-	}
-	ret := make([]byte, base64.StdEncoding.DecodedLen(len(r.token.byteValue)))
-	len, err := base64.StdEncoding.Decode(ret, r.token.byteValue)
-	if err != nil {
-		r.err = &LexerError{
-			Reason: err.Error(),
-		}
-		return nil
-	}
-
-	r.consume()
-	return ret[:len]
-}
-
 // Bool reads a true or false boolean keyword.
 func (r *Lexer) Bool() bool {
 	if r.token.kind == tokenUndef && r.Ok() {