Merge pull request #1 from sbezverk/the_beggining

ceph rbd csi driver
2025-01-17 18:29:30 +00:00 · 2018-01-15 12:12:33 -05:00 · 2018-01-15 12:12:33 -05:00 · 0215b385d3
commit 0215b385d3
parent 558bc6c02a 27334ac60d
16559 changed files with 4528731 additions and 0 deletions
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -0,0 +1,231 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  name = "github.com/PuerkitoBio/purell"
+  packages = ["."]
+  revision = "0bcb03f4b4d0a9428594752bd2a3b9aa0a9d4bd4"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/PuerkitoBio/urlesc"
+  packages = ["."]
+  revision = "de5bf2ad457846296e2031421a34e2568e304e35"
+
+[[projects]]
+  name = "github.com/container-storage-interface/spec"
+  packages = ["lib/go/csi"]
+  revision = "9e88e4bfabeca1b8e4810555815f112159292ada"
+  version = "v0.1.0"
+
+[[projects]]
+  name = "github.com/emicklei/go-restful"
+  packages = [".","log"]
+  revision = "5741799b275a3c4a5a9623a993576d7545cf7b5c"
+  version = "v2.4.0"
+
+[[projects]]
+  name = "github.com/ghodss/yaml"
+  packages = ["."]
+  revision = "0ca9ea5df5451ffdf184b4428c902747c2c11cd7"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/go-openapi/jsonpointer"
+  packages = ["."]
+  revision = "779f45308c19820f1a69e9a4cd965f496e0da10f"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/go-openapi/jsonreference"
+  packages = ["."]
+  revision = "36d33bfe519efae5632669801b180bf1a245da3b"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/go-openapi/spec"
+  packages = ["."]
+  revision = "fa03337d7da5735229ee8f5e9d5d0b996014b7f8"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/go-openapi/swag"
+  packages = ["."]
+  revision = "84f4bee7c0a6db40e3166044c7983c1c32125429"
+
+[[projects]]
+  name = "github.com/gogo/protobuf"
+  packages = ["proto","sortkeys"]
+  revision = "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+  version = "v0.5"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/golang/glog"
+  packages = ["."]
+  revision = "23def4e6c14b4da8ac2ed8007337bc5eb5007998"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/golang/protobuf"
+  packages = ["proto","ptypes","ptypes/any","ptypes/duration","ptypes/timestamp"]
+  revision = "1e59b77b52bf8e4b449a57e6f79f21226d571845"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/google/btree"
+  packages = ["."]
+  revision = "316fb6d3f031ae8f4d457c6c5186b9e3ded70435"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/google/gofuzz"
+  packages = ["."]
+  revision = "24818f796faf91cd76ec7bddd72458fbced7a6c1"
+
+[[projects]]
+  name = "github.com/googleapis/gnostic"
+  packages = ["OpenAPIv2","compiler","extensions"]
+  revision = "ee43cbb60db7bd22502942cccbc39059117352ab"
+  version = "v0.1.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/gregjones/httpcache"
+  packages = [".","diskcache"]
+  revision = "2bcd89a1743fd4b373f7370ce8ddc14dfbd18229"
+
+[[projects]]
+  name = "github.com/json-iterator/go"
+  packages = ["."]
+  revision = "f7279a603edee96fe7764d3de9c6ff8cf9970994"
+  version = "1.0.4"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/juju/ratelimit"
+  packages = ["."]
+  revision = "59fac5042749a5afb9af70e813da1dd5474f0167"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/kubernetes-csi/drivers"
+  packages = ["pkg/csi-common"]
+  revision = "822ddbb41799f02d17e9662d0e34530f7e8061dd"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mailru/easyjson"
+  packages = ["buffer","jlexer","jwriter"]
+  revision = "32fa128f234d041f196a9f3e0fea5ac9772c08e1"
+
+[[projects]]
+  name = "github.com/pborman/uuid"
+  packages = ["."]
+  revision = "e790cca94e6cc75c7064b1332e63811d4aae1a53"
+  version = "v1.1"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/petar/GoLLRB"
+  packages = ["llrb"]
+  revision = "53be0d36a84c2a886ca057d34b6aa4468df9ccb4"
+
+[[projects]]
+  name = "github.com/peterbourgon/diskv"
+  packages = ["."]
+  revision = "5f041e8faa004a95c88a202771f4cc3e991971e6"
+  version = "v2.0.1"
+
+[[projects]]
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  revision = "e57e3eeb33f795204c1ca35f56c44f83227c6e66"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/net"
+  packages = ["context","http2","http2/hpack","idna","internal/timeseries","lex/httplex","trace"]
+  revision = "42fe2e1c20de1054d3d30f82cc9fb5b41e2e3767"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sys"
+  packages = ["unix"]
+  revision = "1792d66dc88e503d3cb2400578221cdf1f7fe26f"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/text"
+  packages = ["collate","collate/build","internal/colltab","internal/gen","internal/tag","internal/triegen","internal/ucd","language","secure/bidirule","transform","unicode/bidi","unicode/cldr","unicode/norm","unicode/rangetable","width"]
+  revision = "e19ae1496984b1c655b8044a65c0300a3c878dd3"
+
+[[projects]]
+  branch = "master"
+  name = "google.golang.org/genproto"
+  packages = ["googleapis/rpc/status"]
+  revision = "a8101f21cf983e773d0c1133ebc5424792003214"
+
+[[projects]]
+  name = "google.golang.org/grpc"
+  packages = [".","balancer","balancer/base","balancer/roundrobin","codes","connectivity","credentials","encoding","grpclb/grpc_lb_v1/messages","grpclog","internal","keepalive","metadata","naming","peer","resolver","resolver/dns","resolver/passthrough","stats","status","tap","transport"]
+  revision = "f3955b8e9e244dd4dd4bc4f7b7a23a8445400a76"
+  version = "v1.9.0"
+
+[[projects]]
+  name = "gopkg.in/inf.v0"
+  packages = ["."]
+  revision = "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
+  version = "v0.9.0"
+
+[[projects]]
+  branch = "v2"
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  revision = "d670f9405373e636a5a2765eea47fac0c9bc91a4"
+
+[[projects]]
+  branch = "master"
+  name = "k8s.io/api"
+  packages = ["admissionregistration/v1alpha1","admissionregistration/v1beta1","apps/v1","apps/v1beta1","apps/v1beta2","authentication/v1","authentication/v1beta1","authorization/v1","authorization/v1beta1","autoscaling/v1","autoscaling/v2beta1","batch/v1","batch/v1beta1","batch/v2alpha1","certificates/v1beta1","core/v1","events/v1beta1","extensions/v1beta1","networking/v1","policy/v1beta1","rbac/v1","rbac/v1alpha1","rbac/v1beta1","scheduling/v1alpha1","settings/v1alpha1","storage/v1","storage/v1alpha1","storage/v1beta1"]
+  revision = "57d7f151236665c12202a51c21bc939eb5d5ba91"
+
+[[projects]]
+  branch = "release-1.9"
+  name = "k8s.io/apimachinery"
+  packages = ["pkg/api/errors","pkg/api/meta","pkg/api/resource","pkg/apis/meta/v1","pkg/apis/meta/v1/unstructured","pkg/apis/meta/v1alpha1","pkg/conversion","pkg/conversion/queryparams","pkg/fields","pkg/labels","pkg/runtime","pkg/runtime/schema","pkg/runtime/serializer","pkg/runtime/serializer/json","pkg/runtime/serializer/protobuf","pkg/runtime/serializer/recognizer","pkg/runtime/serializer/streaming","pkg/runtime/serializer/versioning","pkg/selection","pkg/types","pkg/util/clock","pkg/util/errors","pkg/util/framer","pkg/util/intstr","pkg/util/json","pkg/util/net","pkg/util/runtime","pkg/util/sets","pkg/util/validation","pkg/util/validation/field","pkg/util/wait","pkg/util/yaml","pkg/version","pkg/watch","third_party/forked/golang/reflect"]
+  revision = "68f9c3a1feb3140df59c67ced62d3a5df8e6c9c2"
+
+[[projects]]
+  name = "k8s.io/client-go"
+  packages = ["discovery","kubernetes","kubernetes/scheme","kubernetes/typed/admissionregistration/v1alpha1","kubernetes/typed/admissionregistration/v1beta1","kubernetes/typed/apps/v1","kubernetes/typed/apps/v1beta1","kubernetes/typed/apps/v1beta2","kubernetes/typed/authentication/v1","kubernetes/typed/authentication/v1beta1","kubernetes/typed/authorization/v1","kubernetes/typed/authorization/v1beta1","kubernetes/typed/autoscaling/v1","kubernetes/typed/autoscaling/v2beta1","kubernetes/typed/batch/v1","kubernetes/typed/batch/v1beta1","kubernetes/typed/batch/v2alpha1","kubernetes/typed/certificates/v1beta1","kubernetes/typed/core/v1","kubernetes/typed/events/v1beta1","kubernetes/typed/extensions/v1beta1","kubernetes/typed/networking/v1","kubernetes/typed/policy/v1beta1","kubernetes/typed/rbac/v1","kubernetes/typed/rbac/v1alpha1","kubernetes/typed/rbac/v1beta1","kubernetes/typed/scheduling/v1alpha1","kubernetes/typed/settings/v1alpha1","kubernetes/typed/storage/v1","kubernetes/typed/storage/v1alpha1","kubernetes/typed/storage/v1beta1","pkg/version","rest","rest/watch","tools/clientcmd/api","tools/metrics","tools/reference","transport","util/cert","util/flowcontrol","util/integer"]
+  revision = "78700dec6369ba22221b72770783300f143df150"
+  version = "v6.0.0"
+
+[[projects]]
+  branch = "master"
+  name = "k8s.io/kube-openapi"
+  packages = ["pkg/common"]
+  revision = "a07b7bbb58e7fdc5144f8d7046331d29fc9ad3b3"
+
+[[projects]]
+  name = "k8s.io/kubernetes"
+  packages = ["pkg/util/io","pkg/util/keymutex","pkg/util/mount","pkg/util/nsenter"]
+  revision = "3a1c9449a956b6026f075fa3134ff92f7d55f812"
+  version = "v1.9.1"
+
+[[projects]]
+  branch = "master"
+  name = "k8s.io/utils"
+  packages = ["exec"]
+  revision = "a99a3e11a96751670db62ba77c6d278d1136931e"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "b1c8bd120bec9cbdabfe8c0971602ed9a8dc3da6bde54c8f27805bb79be80b58"
+  solver-name = "gps-cdcl"
+  solver-version = 1
--- a/Gopkg.toml
+++ b/Gopkg.toml
@ -0,0 +1,23 @@
+[[constraint]]
+  version = "v0.1"
+  name = "github.com/container-storage-interface/spec"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/golang/glog"
+
+[[constraint]]
+  name = "google.golang.org/grpc"
+  version = "1.7.2"
+
+[[constraint]]
+  name = "github.com/docker/distribution"
+  revision = "edc3ab29cdff8694dd6feb85cfeb4b5f1b38ed9c"
+
+[[constraint]]
+  name = "k8s.io/kubernetes"
+  version = "v1.9.1"
+
+[[constraint]]
+  name = "k8s.io/apimachinery"
+  version = "kubernetes-1.9.1"
--- a/36
+++ b/36
@ -0,0 +1,36 @@
+# Copyright 2018 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+.PHONY: all rbdplugin
+
+IMAGE_NAME=csi_images/rbdplugin
+IMAGE_VERSION=latest
+
+all: rbdplugin
+
+test:
+	go test github.com/ceph/ceph-csi/pkg/... -cover
+	go vet github.com/ceph/ceph-csi/pkg/...
+
+rbdplugin:
+	if [ ! -d ./vendor ]; then dep ensure; fi
+	go build -i -o _output/rbdplugin ./rbd
+
+container: rbdplugin 
+	cp _output/rbdplugin  deploy/docker
+	docker build -t $(IMAGE_NAME):$(IMAGE_VERSION) deploy/docker
+
+clean:
+	go clean -r -x
+	-rm -rf _output
--- a/deploy/docker/Dockerfile
+++ b/deploy/docker/Dockerfile
@ -0,0 +1,12 @@
+FROM centos:7
+LABEL maintainers="Kubernetes Authors"
+LABEL description="RBD CSI Plugin"
+
+ENV CEPH_VERSION "luminous"
+RUN yum  install -y centos-release-ceph && \
+    yum install -y ceph-common e2fsprogs && \ 
+    yum clean all
+
+COPY rbdplugin /rbdplugin
+RUN chmod +x /rbdplugin
+ENTRYPOINT ["/rbdplugin"]
--- a/deploy/docker/rbdplugin
+++ b/deploy/docker/rbdplugin
--- a/deploy/kubernetes/rbdplugin.yaml
+++ b/deploy/kubernetes/rbdplugin.yaml
@ -0,0 +1,129 @@
+# This YAML defines all API objects to create RBAC roles for csi node plugin.
+
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: csi-nodeplugin
+
+---
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: csi-nodeplugin
+rules:
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["get", "list"]
+  - apiGroups: [""]
+    resources: ["namespaces"]
+    verbs: ["get", "list"]
+  - apiGroups: [""]
+    resources: ["persistentvolumes"]
+    verbs: ["get", "list", "watch", "update"]
+  - apiGroups: ["storage.k8s.io"]
+    resources: ["volumeattachments"]
+    verbs: ["get", "list", "watch", "update"]
+---
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: csi-nodeplugin
+subjects:
+  - kind: ServiceAccount
+    name: csi-nodeplugin
+    namespace: default
+roleRef:
+  kind: ClusterRole
+  name: csi-nodeplugin
+  apiGroup: rbac.authorization.k8s.io          
+
+---
+# This YAML file contains driver-registrar & csi driver nodeplugin API objects,
+# which are necessary to run csi nodeplugin for rbd.
+
+kind: DaemonSet
+apiVersion: apps/v1beta2
+metadata:
+  name: csi-nodeplugin-rbdplugin
+spec:
+  selector:
+    matchLabels:
+      app: csi-nodeplugin-rbdplugin
+  template:
+    metadata:
+      labels:
+        app: csi-nodeplugin-rbdplugin
+    spec:
+      serviceAccount: csi-nodeplugin
+      hostNetwork: true
+      containers:
+        - name: driver-registrar
+          image: csi_images/driver-registrar:latest
+          args:
+            - "--v=5"
+            - "--csi-address=$(ADDRESS)"
+          env:
+            - name: ADDRESS
+              value: /var/lib/kubelet/plugins/rbdplugin/csi.sock
+            - name: KUBE_NODE_NAME
+              valueFrom:
+                fieldRef:
+                  fieldPath: spec.nodeName
+          volumeMounts:
+            - name: socket-dir
+              mountPath: /var/lib/kubelet/plugins/rbdplugin
+        - name: rbdplugin 
+          securityContext:
+            privileged: true
+            capabilities:
+              add: ["SYS_ADMIN"]
+            allowPrivilegeEscalation: true
+          image: csi_images/rbdplugin:latest
+          args :
+            - "--nodeid=$(NODE_ID)"
+            - "--endpoint=$(CSI_ENDPOINT)"
+            - "--v=5"
+            - "--drivername=rbdplugin"
+          env:
+            - name: NODE_ID
+              valueFrom:
+                fieldRef:
+                  fieldPath: spec.nodeName
+            - name: CSI_ENDPOINT
+              value: unix://var/lib/kubelet/plugins/rbdplugin/csi.sock
+          imagePullPolicy: "IfNotPresent"
+          volumeMounts:
+            - name: plugin-dir
+              mountPath: /var/lib/kubelet/plugins/rbdplugin
+            - name: pods-mount-dir
+              mountPath: /var/lib/kubelet/pods
+              mountPropagation: "Bidirectional"
+            - mountPath: /dev
+              name: host-dev
+            - mountPath: /sys
+              name: host-sys
+            - mountPath: /lib/modules
+              name: lib-modules
+              readOnly: true
+      volumes:
+        - name: plugin-dir
+          hostPath:
+            path: /var/lib/kubelet/plugins/rbdplugin
+            type: DirectoryOrCreate
+        - name: pods-mount-dir
+          hostPath:
+            path: /var/lib/kubelet/pods
+            type: Directory
+        - name: socket-dir
+          hostPath:
+            path: /var/lib/kubelet/plugins/rbdplugin
+            type: DirectoryOrCreate
+        - name: host-dev
+          hostPath:
+            path: /dev
+        - name: host-sys
+          hostPath:
+            path: /sys
+        - name: lib-modules
+          hostPath:
+            path: /lib/modules
--- a/pkg/rbd/controllerserver.go
+++ b/pkg/rbd/controllerserver.go
@ -0,0 +1,152 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rbd
+
+import (
+	"fmt"
+	"path"
+
+	"github.com/golang/glog"
+	"github.com/pborman/uuid"
+	"golang.org/x/net/context"
+
+	"k8s.io/client-go/kubernetes"
+
+	"github.com/container-storage-interface/spec/lib/go/csi"
+	"github.com/kubernetes-csi/drivers/pkg/csi-common"
+)
+
+const (
+	oneGB = 1073741824
+)
+
+type controllerServer struct {
+	*csicommon.DefaultControllerServer
+	clientSet *kubernetes.Clientset
+}
+
+func GetVersionString(ver *csi.Version) string {
+	return fmt.Sprintf("%d.%d.%d", ver.Major, ver.Minor, ver.Patch)
+}
+
+func (cs *controllerServer) CreateVolume(ctx context.Context, req *csi.CreateVolumeRequest) (*csi.CreateVolumeResponse, error) {
+	if err := cs.Driver.ValidateControllerServiceRequest(req.Version, csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME); err != nil {
+		glog.V(3).Infof("invalid create volume req: %v", req)
+		return nil, err
+	}
+	// Volume Name
+	volName := req.GetName()
+	if len(volName) == 0 {
+		volName = uuid.NewUUID().String()
+	}
+
+	// Volume Size - Default is 1 GiB
+	volSizeBytes := int64(oneGB)
+	if req.GetCapacityRange() != nil {
+		volSizeBytes = int64(req.GetCapacityRange().GetRequiredBytes())
+	}
+	volSizeGB := int(volSizeBytes / 1024 / 1024 / 1024)
+
+	volOptions, err := getRBDVolumeOptions(req.Parameters, cs.clientSet)
+	if err != nil {
+		return nil, err
+	}
+	// Check if there is already RBD image with requested name
+	found, _, _ := rbdStatus(volName, volOptions)
+	if !found {
+		if err := createRBDImage(volName, volSizeGB, volOptions); err != nil {
+			if err != nil {
+				glog.Warningf("failed to create volume: %v", err)
+				return nil, err
+			}
+		}
+		glog.V(4).Infof("create volume %s", volName)
+	}
+	// Storing volInfo into a persistent file, will need info to delete rbd image
+	// in ControllerUnpublishVolume
+	if err := persistVolInfo(volName, path.Join(PluginFolder, "controller"), volOptions); err != nil {
+		glog.Warningf("rbd: failed to store volInfo with error: %v", err)
+	}
+
+	return &csi.CreateVolumeResponse{
+		VolumeInfo: &csi.VolumeInfo{
+			Id:            volName,
+			CapacityBytes: uint64(volSizeBytes),
+			Attributes:    req.GetParameters(),
+		},
+	}, nil
+}
+
+func (cs *controllerServer) DeleteVolume(ctx context.Context, req *csi.DeleteVolumeRequest) (*csi.DeleteVolumeResponse, error) {
+	if err := cs.Driver.ValidateControllerServiceRequest(req.Version, csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME); err != nil {
+		glog.Warningf("invalid delete volume req: %v", req)
+		return nil, err
+	}
+
+	return &csi.DeleteVolumeResponse{}, nil
+}
+
+func (cs *controllerServer) ValidateVolumeCapabilities(ctx context.Context, req *csi.ValidateVolumeCapabilitiesRequest) (*csi.ValidateVolumeCapabilitiesResponse, error) {
+	for _, cap := range req.VolumeCapabilities {
+		if cap.GetAccessMode().GetMode() != csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER {
+			return &csi.ValidateVolumeCapabilitiesResponse{Supported: false, Message: ""}, nil
+		}
+	}
+	return &csi.ValidateVolumeCapabilitiesResponse{Supported: true, Message: ""}, nil
+}
+
+func (cs *controllerServer) ControllerUnpublishVolume(ctx context.Context, req *csi.ControllerUnpublishVolumeRequest) (*csi.ControllerUnpublishVolumeResponse, error) {
+
+	// For now the image get unconditionally deleted, but here retention policy can be checked
+	volName := req.GetVolumeId()
+	volOptions := &rbdVolumeOptions{}
+	if err := loadVolInfo(volName, path.Join(PluginFolder, "controller"), volOptions); err != nil {
+		return nil, err
+	}
+
+	// Recover rbd secret key value, for now by k8s specific call
+	id := volOptions.AdminID
+	secretName := volOptions.AdminSecretName
+	secretNamespace := volOptions.AdminSecretNamespace
+	if id == "" {
+		secretName = volOptions.UserSecretName
+		secretNamespace = volOptions.UserSecretNamespace
+	}
+	if key, err := parseStorageClassSecret(secretName, secretNamespace, cs.clientSet); err != nil {
+		return nil, err
+	} else {
+		volOptions.adminSecret = key
+	}
+
+	// Deleting rbd image
+	glog.V(4).Infof("deleting volume %s", volName)
+	if err := deleteRBDImage(volName, volOptions); err != nil {
+		glog.V(3).Infof("failed to delete rbd image: %s/%s with error: %v", volOptions.Pool, volName, err)
+		return nil, err
+	}
+	// Removing persistent storage file for the unmapped volume
+	if err := deleteVolInfo(volName, path.Join(PluginFolder, "controller")); err != nil {
+		return nil, err
+	}
+
+	return &csi.ControllerUnpublishVolumeResponse{}, nil
+}
+
+func (cs *controllerServer) ControllerPublishVolume(ctx context.Context, req *csi.ControllerPublishVolumeRequest) (*csi.ControllerPublishVolumeResponse, error) {
+
+	return &csi.ControllerPublishVolumeResponse{}, nil
+}
--- a/pkg/rbd/identityserver.go
+++ b/pkg/rbd/identityserver.go
@ -0,0 +1,25 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rbd
+
+import (
+	"github.com/kubernetes-csi/drivers/pkg/csi-common"
+)
+
+type identityServer struct {
+	*csicommon.DefaultIdentityServer
+}
--- a/pkg/rbd/nodeserver.go
+++ b/pkg/rbd/nodeserver.go
@ -0,0 +1,144 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rbd
+
+import (
+	"os"
+	"path"
+
+	"github.com/golang/glog"
+	"golang.org/x/net/context"
+
+	"github.com/container-storage-interface/spec/lib/go/csi"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/kubernetes/pkg/util/mount"
+
+	"github.com/kubernetes-csi/drivers/pkg/csi-common"
+)
+
+type nodeServer struct {
+	*csicommon.DefaultNodeServer
+	clientSet *kubernetes.Clientset
+}
+
+func (ns *nodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublishVolumeRequest) (*csi.NodePublishVolumeResponse, error) {
+	targetPath := req.GetTargetPath()
+
+	notMnt, err := mount.New("").IsLikelyNotMountPoint(targetPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			if err = os.MkdirAll(targetPath, 0750); err != nil {
+				return nil, status.Error(codes.Internal, err.Error())
+			}
+			notMnt = true
+		} else {
+			return nil, status.Error(codes.Internal, err.Error())
+		}
+	}
+
+	if !notMnt {
+		return &csi.NodePublishVolumeResponse{}, nil
+	}
+	volOptions, err := getRBDVolumeOptions(req.VolumeAttributes, ns.clientSet)
+	if err != nil {
+		return nil, err
+	}
+
+	// Mapping RBD image
+	devicePath, err := attachRBDImage(req.GetVolumeId(), volOptions)
+	if err != nil {
+		return nil, err
+	}
+	glog.V(4).Infof("rbd image: %s/%s was succesfully mapped at %s\n", req.GetVolumeId(), volOptions.Pool, devicePath)
+	fsType := req.GetVolumeCapability().GetMount().GetFsType()
+
+	readOnly := req.GetReadonly()
+	attrib := req.GetVolumeAttributes()
+	mountFlags := req.GetVolumeCapability().GetMount().GetMountFlags()
+
+	glog.V(4).Infof("target %v\nfstype %v\ndevice %v\nreadonly %v\nattributes %v\n mountflags %v\n",
+		targetPath, fsType, devicePath, readOnly, attrib, mountFlags)
+
+	options := []string{}
+	if readOnly {
+		options = append(options, "ro")
+	}
+
+	diskMounter := &mount.SafeFormatAndMount{Interface: mount.New(""), Exec: mount.NewOsExec()}
+	if err := diskMounter.FormatAndMount(devicePath, targetPath, fsType, options); err != nil {
+		return nil, err
+	}
+	// Storing rbd device path
+
+	volOptions.ImageMapping = map[string]string{req.GetVolumeId(): devicePath}
+	// Storing volInfo into a persistent file
+	if err := persistVolInfo(req.GetVolumeId(), path.Join(PluginFolder, "node"), volOptions); err != nil {
+		glog.Warningf("rbd: failed to store volInfo with error: %v", err)
+	}
+
+	return &csi.NodePublishVolumeResponse{}, nil
+}
+
+func (ns *nodeServer) NodeUnpublishVolume(ctx context.Context, req *csi.NodeUnpublishVolumeRequest) (*csi.NodeUnpublishVolumeResponse, error) {
+	targetPath := req.GetTargetPath()
+	volName := req.GetVolumeId()
+	volOptions := &rbdVolumeOptions{}
+	if err := loadVolInfo(volName, path.Join(PluginFolder, "node"), volOptions); err != nil {
+		return nil, err
+	}
+
+	// Recover rbd secret key value, for now by k8s specific call
+	id := volOptions.AdminID
+	secretName := volOptions.AdminSecretName
+	secretNamespace := volOptions.AdminSecretNamespace
+	if id == "" {
+		secretName = volOptions.UserSecretName
+		secretNamespace = volOptions.UserSecretNamespace
+	}
+	if key, err := parseStorageClassSecret(secretName, secretNamespace, ns.clientSet); err != nil {
+		return nil, err
+	} else {
+		volOptions.adminSecret = key
+	}
+
+	notMnt, err := mount.New("").IsLikelyNotMountPoint(targetPath)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+	if notMnt {
+		return nil, status.Error(codes.NotFound, "Volume not mounted")
+	}
+	// Unmounting the image
+	err = mount.New("").Unmount(req.GetTargetPath())
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+	// Unmapping rbd device
+	glog.V(4).Infof("deleting volume %s", volName)
+	if err := detachRBDImage(volName, volOptions); err != nil {
+		glog.V(3).Infof("failed to unmap rbd device: %s with error: %v", volOptions.ImageMapping[volName], err)
+		return nil, err
+	}
+	// Removing persistent storage file for the unmapped volume
+	if err := deleteVolInfo(volName, path.Join(PluginFolder, "node")); err != nil {
+		return nil, err
+	}
+
+	return &csi.NodeUnpublishVolumeResponse{}, nil
+}
--- a/pkg/rbd/rbd.go
+++ b/pkg/rbd/rbd.go
@ -0,0 +1,99 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rbd
+
+import (
+	"github.com/container-storage-interface/spec/lib/go/csi"
+	"github.com/golang/glog"
+
+	"github.com/kubernetes-csi/drivers/pkg/csi-common"
+	"k8s.io/client-go/kubernetes"
+)
+
+// PluginFolder defines the location of rbdplugin
+const (
+	PluginFolder = "/var/lib/kubelet/plugins/rbdplugin"
+)
+
+type rbd struct {
+	driver *csicommon.CSIDriver
+
+	ids *identityServer
+	ns  *nodeServer
+	cs  *controllerServer
+
+	cap   []*csi.VolumeCapability_AccessMode
+	cscap []*csi.ControllerServiceCapability
+}
+
+var (
+	rbdDriver *rbd
+	version   = csi.Version{
+		Minor: 1,
+	}
+)
+
+func GetSupportedVersions() []*csi.Version {
+	return []*csi.Version{&version}
+}
+
+func GetRBDDriver() *rbd {
+	return &rbd{}
+}
+
+func NewIdentityServer(d *csicommon.CSIDriver) *identityServer {
+	return &identityServer{
+		DefaultIdentityServer: csicommon.NewDefaultIdentityServer(d),
+	}
+}
+
+func NewControllerServer(d *csicommon.CSIDriver, clientSet *kubernetes.Clientset) *controllerServer {
+	return &controllerServer{
+		DefaultControllerServer: csicommon.NewDefaultControllerServer(d),
+		clientSet:               clientSet,
+	}
+}
+
+func NewNodeServer(d *csicommon.CSIDriver, clientSet *kubernetes.Clientset) *nodeServer {
+	return &nodeServer{
+		DefaultNodeServer: csicommon.NewDefaultNodeServer(d),
+		clientSet:         clientSet,
+	}
+}
+
+func (rbd *rbd) Run(driverName, nodeID, endpoint string, clientSet *kubernetes.Clientset) {
+	glog.Infof("Driver: %v version: %v", driverName, GetVersionString(&version))
+
+	// Initialize default library driver
+	rbd.driver = csicommon.NewCSIDriver(driverName, &version, GetSupportedVersions(), nodeID)
+	if rbd.driver == nil {
+		glog.Fatalln("Failed to initialize CSI Driver.")
+	}
+	rbd.driver.AddControllerServiceCapabilities([]csi.ControllerServiceCapability_RPC_Type{
+		csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME,
+		csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME,
+	})
+	rbd.driver.AddVolumeCapabilityAccessModes([]csi.VolumeCapability_AccessMode_Mode{csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER})
+
+	// Create GRPC servers
+	rbd.ids = NewIdentityServer(rbd.driver)
+	rbd.ns = NewNodeServer(rbd.driver, clientSet)
+	rbd.cs = NewControllerServer(rbd.driver, clientSet)
+	s := csicommon.NewNonBlockingGRPCServer()
+	s.Start(endpoint, rbd.ids, rbd.cs, rbd.ns)
+	s.Wait()
+}
--- a/pkg/rbd/rbd_util.go
+++ b/pkg/rbd/rbd_util.go
@ -0,0 +1,420 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rbd
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/golang/glog"
+	"io/ioutil"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/kubernetes/pkg/util/keymutex"
+	"os"
+	"os/exec"
+	"path"
+	"strings"
+	"time"
+)
+
+const (
+	imageWatcherStr = "watcher="
+	rbdImageFormat1 = "1"
+	rbdImageFormat2 = "2"
+	imageSizeStr    = "size "
+	sizeDivStr      = " MB in"
+	kubeLockMagic   = "kubelet_lock_magic_"
+	// The following three values are used for 30 seconds timeout
+	// while waiting for RBD Watcher to expire.
+	rbdImageWatcherInitDelay = 1 * time.Second
+	rbdImageWatcherFactor    = 1.4
+	rbdImageWatcherSteps     = 10
+)
+
+type rbdVolumeOptions struct {
+	Monitors             string            `json:"monitors"`
+	Pool                 string            `json:"pool"`
+	AdminSecretName      string            `json:"adminSecret"`
+	AdminSecretNamespace string            `json:"adminSecretNamespace"`
+	AdminID              string            `json:"adminID"`
+	UserID               string            `json:"userID"`
+	UserSecretName       string            `json:"userSecret"`
+	UserSecretNamespace  string            `json:"userSecretNamespace"`
+	ImageFormat          string            `json:"imageFormat"`
+	ImageFeatures        []string          `json:"imageFeatures"`
+	ImageMapping         map[string]string `json:"imageMapping"`
+	adminSecret          string
+	userSecret           string
+}
+
+var attachdetachMutex = keymutex.NewKeyMutex()
+
+// CreateImage creates a new ceph image with provision and volume options.
+func createRBDImage(image string, volSz int, pOpts *rbdVolumeOptions) error {
+	var output []byte
+	var err error
+
+	// rbd create
+	mon := pOpts.Monitors
+	volSzGB := fmt.Sprintf("%dG", volSz)
+
+	if pOpts.ImageFormat == rbdImageFormat2 {
+		glog.V(4).Infof("rbd: create %s size %s format %s (features: %s) using mon %s, pool %s id %s key %s", image, volSzGB, pOpts.ImageFormat, pOpts.ImageFeatures, mon, pOpts.Pool, pOpts.AdminID, pOpts.adminSecret)
+	} else {
+		glog.V(4).Infof("rbd: create %s size %s format %s using mon %s, pool %s id %s key %s", image, volSzGB, pOpts.ImageFormat, mon, pOpts.Pool, pOpts.AdminID, pOpts.adminSecret)
+	}
+	args := []string{"create", image, "--size", volSzGB, "--pool", pOpts.Pool, "--id", pOpts.AdminID, "-m", mon, "--key=" + pOpts.adminSecret, "--image-format", pOpts.ImageFormat}
+	if pOpts.ImageFormat == rbdImageFormat2 {
+		// if no image features is provided, it results in empty string
+		// which disable all RBD image format 2 features as we expected
+		features := strings.Join(pOpts.ImageFeatures, ",")
+		args = append(args, "--image-feature", features)
+	}
+	output, err = execCommand("rbd", args)
+
+	if err != nil {
+		return fmt.Errorf("failed to create rbd image: %v, command output: %s", err, string(output))
+	}
+
+	return nil
+}
+
+// rbdStatus checks if there is watcher on the image.
+// It returns true if there is a watcher onthe image, otherwise returns false.
+func rbdStatus(image string, b *rbdVolumeOptions) (bool, string, error) {
+	var err error
+	var output string
+	var cmd []byte
+
+	// If we don't have admin id/secret (e.g. attaching), fallback to user id/secret.
+	id := b.AdminID
+	secret := b.adminSecret
+	if id == "" {
+		id = b.UserID
+		secret = b.userSecret
+	}
+
+	glog.V(4).Infof("rbd: status %s using mon %s, pool %s id %s key %s", image, b.Monitors, b.Pool, id, secret)
+	args := []string{"status", image, "--pool", b.Pool, "-m", b.Monitors, "--id", id, "--key=" + secret}
+	cmd, err = execCommand("rbd", args)
+	output = string(cmd)
+
+	if err, ok := err.(*exec.Error); ok {
+		if err.Err == exec.ErrNotFound {
+			glog.Errorf("rbd cmd not found")
+			// fail fast if command not found
+			return false, output, err
+		}
+	}
+
+	// If command never succeed, returns its last error.
+	if err != nil {
+		return false, output, err
+	}
+
+	if strings.Contains(output, imageWatcherStr) {
+		glog.V(4).Infof("rbd: watchers on %s: %s", image, output)
+		return true, output, nil
+	} else {
+		glog.Warningf("rbd: no watchers on %s", image)
+		return false, output, nil
+	}
+}
+
+// DeleteImage deletes a ceph image with provision and volume options.
+func deleteRBDImage(image string, b *rbdVolumeOptions) error {
+	var output []byte
+	found, _, err := rbdStatus(image, b)
+	if err != nil {
+		return err
+	}
+	if found {
+		glog.Info("rbd is still being used ", image)
+		return fmt.Errorf("rbd %s is still being used", image)
+	}
+	id := b.AdminID
+	secret := b.adminSecret
+	if id == "" {
+		id = b.UserID
+		secret = b.userSecret
+	}
+
+	glog.V(4).Infof("rbd: rm %s using mon %s, pool %s id %s key %s", image, b.Monitors, b.Pool, id, secret)
+	args := []string{"rm", image, "--pool", b.Pool, "--id", id, "-m", b.Monitors, "--key=" + secret}
+	output, err = execCommand("rbd", args)
+	if err == nil {
+		return nil
+	}
+	glog.Errorf("failed to delete rbd image: %v, command output: %s", err, string(output))
+	return err
+}
+
+func execCommand(command string, args []string) ([]byte, error) {
+	cmd := exec.Command(command, args...)
+	return cmd.CombinedOutput()
+}
+
+func getRBDVolumeOptions(volOptions map[string]string, client *kubernetes.Clientset) (*rbdVolumeOptions, error) {
+	rbdVolume := &rbdVolumeOptions{}
+	var ok bool
+	var err error
+	rbdVolume.AdminID, ok = volOptions["adminId"]
+	if !ok {
+		return nil, fmt.Errorf("Missing required parameter adminId")
+	}
+	rbdVolume.AdminSecretName, ok = volOptions["adminSecretName"]
+	if !ok {
+		return nil, fmt.Errorf("Missing required parameter adminSecretName")
+	}
+	rbdVolume.AdminSecretNamespace, ok = volOptions["adminSecretNamespace"]
+	if !ok {
+		rbdVolume.AdminSecretNamespace = "default"
+	}
+	rbdVolume.adminSecret, err = parseStorageClassSecret(rbdVolume.AdminSecretName, rbdVolume.AdminSecretNamespace, client)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to retrieve Admin secret %v", err)
+	}
+	rbdVolume.Pool, ok = volOptions["pool"]
+	if !ok {
+		return nil, fmt.Errorf("Missing required parameter pool")
+	}
+	rbdVolume.Monitors, ok = volOptions["monitors"]
+	if !ok {
+		return nil, fmt.Errorf("Missing required parameter monitors")
+	}
+	if err != nil {
+		return nil, err
+	}
+	rbdVolume.UserID, ok = volOptions["userId"]
+	if !ok {
+		return nil, fmt.Errorf("Missing required parameter userId")
+	}
+	rbdVolume.UserSecretName, ok = volOptions["userSecretName"]
+	if ok {
+		rbdVolume.UserSecretNamespace, ok = volOptions["userSecretNamespace"]
+		if !ok {
+			rbdVolume.UserSecretNamespace = "default"
+		}
+		rbdVolume.userSecret, err = parseStorageClassSecret(rbdVolume.UserSecretName, rbdVolume.UserSecretNamespace, client)
+		if err != nil {
+			glog.Errorf("failed to retrieve user's secret: %s/%s  (%v)", rbdVolume.UserSecretName, rbdVolume.UserSecretNamespace, err)
+		}
+	}
+	rbdVolume.ImageFormat, ok = volOptions["imageFormat"]
+	if !ok {
+		rbdVolume.ImageFormat = "2"
+	}
+
+	return rbdVolume, nil
+}
+
+func parseStorageClassSecret(secretName string, namespace string, client *kubernetes.Clientset) (string, error) {
+	if client == nil {
+		return "", fmt.Errorf("Cannot get kube client")
+	}
+	secrets, err := client.CoreV1().Secrets(namespace).Get(secretName, metav1.GetOptions{})
+	if err != nil {
+		return "", err
+	}
+	secret := ""
+	for k, v := range secrets.Data {
+		if k == secretName {
+			return string(v), nil
+		}
+		secret = string(v)
+	}
+
+	return secret, nil
+}
+
+func attachRBDImage(image string, volOptions *rbdVolumeOptions) (string, error) {
+	var err error
+	var output []byte
+
+	devicePath, found := waitForPath(volOptions.Pool, image, 1)
+	if !found {
+		attachdetachMutex.LockKey(string(volOptions.Pool + image))
+		defer attachdetachMutex.UnlockKey(string(volOptions.Pool + image))
+
+		_, err = execCommand("modprobe", []string{"rbd"})
+		if err != nil {
+			glog.Warningf("rbd: failed to load rbd kernel module:%v", err)
+		}
+
+		backoff := wait.Backoff{
+			Duration: rbdImageWatcherInitDelay,
+			Factor:   rbdImageWatcherFactor,
+			Steps:    rbdImageWatcherSteps,
+		}
+		err := wait.ExponentialBackoff(backoff, func() (bool, error) {
+			used, rbdOutput, err := rbdStatus(image, volOptions)
+			if err != nil {
+				return false, fmt.Errorf("fail to check rbd image status with: (%v), rbd output: (%s)", err, rbdOutput)
+			}
+			return !used, nil
+		})
+		// return error if rbd image has not become available for the specified timeout
+		if err == wait.ErrWaitTimeout {
+			return "", fmt.Errorf("rbd image %s/%s is still being used", volOptions.Pool, image)
+		}
+		// return error if any other errors were encountered during wating for the image to becme avialble
+		if err != nil {
+			return "", err
+		}
+
+		glog.V(1).Infof("rbd: map mon %s", volOptions.Monitors)
+		// If we don't have admin id/secret (e.g. attaching), fallback to user id/secret.
+		id := volOptions.AdminID
+		secret := volOptions.adminSecret
+		if id == "" {
+			id = volOptions.UserID
+			secret = volOptions.userSecret
+		}
+
+		output, err = execCommand("rbd", []string{
+			"map", image, "--pool", volOptions.Pool, "--id", id, "-m", volOptions.Monitors, "--key=" + secret})
+		if err != nil {
+			glog.V(1).Infof("rbd: map error %v, rbd output: %s", err, string(output))
+			return "", fmt.Errorf("rbd: map failed %v, rbd output: %s", err, string(output))
+		}
+		devicePath, found = waitForPath(volOptions.Pool, image, 10)
+		if !found {
+			return "", fmt.Errorf("Could not map image %s/%s, Timeout after 10s", volOptions.Pool, image)
+		}
+	}
+
+	return devicePath, nil
+}
+
+func detachRBDImage(image string, volOptions *rbdVolumeOptions) error {
+	var err error
+	var output []byte
+
+	glog.V(1).Infof("rbd: unmap device %s", volOptions.ImageMapping[image])
+	// If we don't have admin id/secret (e.g. attaching), fallback to user id/secret.
+	id := volOptions.AdminID
+	secret := volOptions.adminSecret
+	if id == "" {
+		id = volOptions.UserID
+		secret = volOptions.userSecret
+	}
+
+	output, err = execCommand("rbd", []string{
+		"unmap", volOptions.ImageMapping[image], "--id", id, "--key=" + secret})
+	if err != nil {
+		glog.V(1).Infof("rbd: unmap error %v, rbd output: %s", err, string(output))
+		return fmt.Errorf("rbd: unmap failed %v, rbd output: %s", err, string(output))
+	}
+
+	return nil
+}
+
+func getDevFromImageAndPool(pool, image string) (string, bool) {
+	// /sys/bus/rbd/devices/X/name and /sys/bus/rbd/devices/X/pool
+	sys_path := "/sys/bus/rbd/devices"
+	if dirs, err := ioutil.ReadDir(sys_path); err == nil {
+		for _, f := range dirs {
+			name := f.Name()
+			// first match pool, then match name
+			poolFile := path.Join(sys_path, name, "pool")
+			poolBytes, err := ioutil.ReadFile(poolFile)
+			if err != nil {
+				glog.V(4).Infof("Error reading %s: %v", poolFile, err)
+				continue
+			}
+			if strings.TrimSpace(string(poolBytes)) != pool {
+				glog.V(4).Infof("Device %s is not %q: %q", name, pool, string(poolBytes))
+				continue
+			}
+			imgFile := path.Join(sys_path, name, "name")
+			imgBytes, err := ioutil.ReadFile(imgFile)
+			if err != nil {
+				glog.V(4).Infof("Error reading %s: %v", imgFile, err)
+				continue
+			}
+			if strings.TrimSpace(string(imgBytes)) != image {
+				glog.V(4).Infof("Device %s is not %q: %q", name, image, string(imgBytes))
+				continue
+			}
+			// found a match, check if device exists
+			devicePath := "/dev/rbd" + name
+			if _, err := os.Lstat(devicePath); err == nil {
+				return devicePath, true
+			}
+		}
+	}
+	return "", false
+}
+
+// stat a path, if not exists, retry maxRetries times
+func waitForPath(pool, image string, maxRetries int) (string, bool) {
+	for i := 0; i < maxRetries; i++ {
+		devicePath, found := getDevFromImageAndPool(pool, image)
+		if found {
+			return devicePath, true
+		}
+		if i == maxRetries-1 {
+			break
+		}
+		time.Sleep(time.Second)
+	}
+	return "", false
+}
+
+func persistVolInfo(image string, persistentStoragePath string, volInfo *rbdVolumeOptions) error {
+	file := path.Join(persistentStoragePath, image+".json")
+	fp, err := os.Create(file)
+	if err != nil {
+		return fmt.Errorf("rbd: create err %s/%s", file, err)
+	}
+	defer fp.Close()
+
+	encoder := json.NewEncoder(fp)
+	if err = encoder.Encode(volInfo); err != nil {
+		return fmt.Errorf("rbd: encode err: %v.", err)
+	}
+
+	return nil
+}
+
+func loadVolInfo(image string, persistentStoragePath string, volInfo *rbdVolumeOptions) error {
+	file := path.Join(persistentStoragePath, image+".json")
+	fp, err := os.Open(file)
+	if err != nil {
+		return fmt.Errorf("rbd: open err %s/%s", file, err)
+	}
+	defer fp.Close()
+
+	decoder := json.NewDecoder(fp)
+	if err = decoder.Decode(volInfo); err != nil {
+		return fmt.Errorf("rbd: decode err: %v.", err)
+	}
+
+	return nil
+}
+
+func deleteVolInfo(image string, persistentStoragePath string) error {
+	file := path.Join(persistentStoragePath, image+".json")
+	err := os.Remove(file)
+	if err != nil {
+		if err != os.ErrNotExist {
+			return fmt.Errorf("rbd: open err %s/%s", file, err)
+		}
+	}
+	return nil
+}
--- a/rbd/main.go
+++ b/rbd/main.go
@ -0,0 +1,80 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+import (
+	"flag"
+	"github.com/golang/glog"
+	"os"
+	"path"
+
+	"github.com/ceph/ceph-csi/pkg/rbd"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
+)
+
+func init() {
+	flag.Set("logtostderr", "true")
+}
+
+var (
+	endpoint   = flag.String("endpoint", "unix://tmp/csi.sock", "CSI endpoint")
+	driverName = flag.String("drivername", "rbdplugin", "name of the driver")
+	nodeID     = flag.String("nodeid", "", "node id")
+)
+
+func main() {
+	flag.Parse()
+
+	// creates the in-cluster config
+	config, err := rest.InClusterConfig()
+	if err != nil {
+		panic(err.Error())
+	}
+	// creates the clientset
+	clientSet, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	if err := createPersistentStorage(path.Join(rbd.PluginFolder, "controller")); err != nil {
+		glog.Errorf("failed to create persistent storage for controller %v", err)
+		os.Exit(1)
+	}
+	if err := createPersistentStorage(path.Join(rbd.PluginFolder, "node")); err != nil {
+		glog.Errorf("failed to create persistent storage for node %v", err)
+		os.Exit(1)
+	}
+
+	handle(clientSet)
+	os.Exit(0)
+}
+
+func handle(clientSet *kubernetes.Clientset) {
+	driver := rbd.GetRBDDriver()
+	driver.Run(*driverName, *nodeID, *endpoint, clientSet)
+}
+
+func createPersistentStorage(persistentStoragePath string) error {
+	if _, err := os.Stat(persistentStoragePath); os.IsNotExist(err) {
+		if err := os.MkdirAll(persistentStoragePath, os.FileMode(0755)); err != nil {
+			return err
+		}
+	} else {
+	}
+	return nil
+}
--- a/vendor/github.com/PuerkitoBio/purell/.gitignore
+++ b/vendor/github.com/PuerkitoBio/purell/.gitignore
@ -0,0 +1,5 @@
+*.sublime-*
+.DS_Store
+*.swp
+*.swo
+tags
--- a/vendor/github.com/PuerkitoBio/purell/.travis.yml
+++ b/vendor/github.com/PuerkitoBio/purell/.travis.yml
@ -0,0 +1,7 @@
+language: go
+
+go:
+    - 1.4
+    - 1.5
+    - 1.6
+    - tip
--- a/vendor/github.com/PuerkitoBio/purell/LICENSE
+++ b/vendor/github.com/PuerkitoBio/purell/LICENSE
@ -0,0 +1,12 @@
+Copyright (c) 2012, Martin Angers
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/vendor/github.com/PuerkitoBio/purell/README.md
+++ b/vendor/github.com/PuerkitoBio/purell/README.md
@ -0,0 +1,187 @@
+# Purell
+
+Purell is a tiny Go library to normalize URLs. It returns a pure URL. Pure-ell. Sanitizer and all. Yeah, I know...
+
+Based on the [wikipedia paper][wiki] and the [RFC 3986 document][rfc].
+
+[![build status](https://secure.travis-ci.org/PuerkitoBio/purell.png)](http://travis-ci.org/PuerkitoBio/purell)
+
+## Install
+
+`go get github.com/PuerkitoBio/purell`
+
+## Changelog
+
+*    **2016-11-14 (v1.1.0)** : IDN: Conform to RFC 5895: Fold character width (thanks to @beeker1121).
+*    **2016-07-27 (v1.0.0)** : Normalize IDN to ASCII (thanks to @zenovich).
+*    **2015-02-08** : Add fix for relative paths issue ([PR #5][pr5]) and add fix for unnecessary encoding of reserved characters ([see issue #7][iss7]).
+*    **v0.2.0** : Add benchmarks, Attempt IDN support.
+*    **v0.1.0** : Initial release.
+
+## Examples
+
+From `example_test.go` (note that in your code, you would import "github.com/PuerkitoBio/purell", and would prefix references to its methods and constants with "purell."):
+
+```go
+package purell
+
+import (
+  "fmt"
+  "net/url"
+)
+
+func ExampleNormalizeURLString() {
+  if normalized, err := NormalizeURLString("hTTp://someWEBsite.com:80/Amazing%3f/url/",
+    FlagLowercaseScheme|FlagLowercaseHost|FlagUppercaseEscapes); err != nil {
+    panic(err)
+  } else {
+    fmt.Print(normalized)
+  }
+  // Output: http://somewebsite.com:80/Amazing%3F/url/
+}
+
+func ExampleMustNormalizeURLString() {
+  normalized := MustNormalizeURLString("hTTpS://someWEBsite.com:443/Amazing%fa/url/",
+    FlagsUnsafeGreedy)
+  fmt.Print(normalized)
+
+  // Output: http://somewebsite.com/Amazing%FA/url
+}
+
+func ExampleNormalizeURL() {
+  if u, err := url.Parse("Http://SomeUrl.com:8080/a/b/.././c///g?c=3&a=1&b=9&c=0#target"); err != nil {
+    panic(err)
+  } else {
+    normalized := NormalizeURL(u, FlagsUsuallySafeGreedy|FlagRemoveDuplicateSlashes|FlagRemoveFragment)
+    fmt.Print(normalized)
+  }
+
+  // Output: http://someurl.com:8080/a/c/g?c=3&a=1&b=9&c=0
+}
+```
+
+## API
+
+As seen in the examples above, purell offers three methods, `NormalizeURLString(string, NormalizationFlags) (string, error)`, `MustNormalizeURLString(string, NormalizationFlags) (string)` and `NormalizeURL(*url.URL, NormalizationFlags) (string)`. They all normalize the provided URL based on the specified flags. Here are the available flags:
+
+```go
+const (
+	// Safe normalizations
+	FlagLowercaseScheme           NormalizationFlags = 1 << iota // HTTP://host -> http://host, applied by default in Go1.1
+	FlagLowercaseHost                                            // http://HOST -> http://host
+	FlagUppercaseEscapes                                         // http://host/t%ef -> http://host/t%EF
+	FlagDecodeUnnecessaryEscapes                                 // http://host/t%41 -> http://host/tA
+	FlagEncodeNecessaryEscapes                                   // http://host/!"#$ -> http://host/%21%22#$
+	FlagRemoveDefaultPort                                        // http://host:80 -> http://host
+	FlagRemoveEmptyQuerySeparator                                // http://host/path? -> http://host/path
+
+	// Usually safe normalizations
+	FlagRemoveTrailingSlash // http://host/path/ -> http://host/path
+	FlagAddTrailingSlash    // http://host/path -> http://host/path/ (should choose only one of these add/remove trailing slash flags)
+	FlagRemoveDotSegments   // http://host/path/./a/b/../c -> http://host/path/a/c
+
+	// Unsafe normalizations
+	FlagRemoveDirectoryIndex   // http://host/path/index.html -> http://host/path/
+	FlagRemoveFragment         // http://host/path#fragment -> http://host/path
+	FlagForceHTTP              // https://host -> http://host
+	FlagRemoveDuplicateSlashes // http://host/path//a///b -> http://host/path/a/b
+	FlagRemoveWWW              // http://www.host/ -> http://host/
+	FlagAddWWW                 // http://host/ -> http://www.host/ (should choose only one of these add/remove WWW flags)
+	FlagSortQuery              // http://host/path?c=3&b=2&a=1&b=1 -> http://host/path?a=1&b=1&b=2&c=3
+
+	// Normalizations not in the wikipedia article, required to cover tests cases
+	// submitted by jehiah
+	FlagDecodeDWORDHost           // http://1113982867 -> http://66.102.7.147
+	FlagDecodeOctalHost           // http://0102.0146.07.0223 -> http://66.102.7.147
+	FlagDecodeHexHost             // http://0x42660793 -> http://66.102.7.147
+	FlagRemoveUnnecessaryHostDots // http://.host../path -> http://host/path
+	FlagRemoveEmptyPortSeparator  // http://host:/path -> http://host/path
+
+	// Convenience set of safe normalizations
+	FlagsSafe NormalizationFlags = FlagLowercaseHost | FlagLowercaseScheme | FlagUppercaseEscapes | FlagDecodeUnnecessaryEscapes | FlagEncodeNecessaryEscapes | FlagRemoveDefaultPort | FlagRemoveEmptyQuerySeparator
+
+	// For convenience sets, "greedy" uses the "remove trailing slash" and "remove www. prefix" flags,
+	// while "non-greedy" uses the "add (or keep) the trailing slash" and "add www. prefix".
+
+	// Convenience set of usually safe normalizations (includes FlagsSafe)
+	FlagsUsuallySafeGreedy    NormalizationFlags = FlagsSafe | FlagRemoveTrailingSlash | FlagRemoveDotSegments
+	FlagsUsuallySafeNonGreedy NormalizationFlags = FlagsSafe | FlagAddTrailingSlash | FlagRemoveDotSegments
+
+	// Convenience set of unsafe normalizations (includes FlagsUsuallySafe)
+	FlagsUnsafeGreedy    NormalizationFlags = FlagsUsuallySafeGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagRemoveWWW | FlagSortQuery
+	FlagsUnsafeNonGreedy NormalizationFlags = FlagsUsuallySafeNonGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagAddWWW | FlagSortQuery
+
+	// Convenience set of all available flags
+	FlagsAllGreedy    = FlagsUnsafeGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
+	FlagsAllNonGreedy = FlagsUnsafeNonGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
+)
+```
+
+For convenience, the set of flags `FlagsSafe`, `FlagsUsuallySafe[Greedy|NonGreedy]`, `FlagsUnsafe[Greedy|NonGreedy]` and `FlagsAll[Greedy|NonGreedy]` are provided for the similarly grouped normalizations on [wikipedia's URL normalization page][wiki]. You can add (using the bitwise OR `|` operator) or remove (using the bitwise AND NOT `&^` operator) individual flags from the sets if required, to build your own custom set.
+
+The [full godoc reference is available on gopkgdoc][godoc].
+
+Some things to note:
+
+*    `FlagDecodeUnnecessaryEscapes`, `FlagEncodeNecessaryEscapes`, `FlagUppercaseEscapes` and `FlagRemoveEmptyQuerySeparator` are always implicitly set, because internally, the URL string is parsed as an URL object, which automatically decodes unnecessary escapes, uppercases and encodes necessary ones, and removes empty query separators (an unnecessary `?` at the end of the url). So this operation cannot **not** be done. For this reason, `FlagRemoveEmptyQuerySeparator` (as well as the other three) has been included in the `FlagsSafe` convenience set, instead of `FlagsUnsafe`, where Wikipedia puts it.
+
+*    The `FlagDecodeUnnecessaryEscapes` decodes the following escapes (*from -> to*):
+    -    %24 -> $
+    -    %26 -> &
+    -    %2B-%3B -> +,-./0123456789:;
+    -    %3D -> =
+    -    %40-%5A -> @ABCDEFGHIJKLMNOPQRSTUVWXYZ
+    -    %5F -> _
+    -    %61-%7A -> abcdefghijklmnopqrstuvwxyz
+    -    %7E -> ~
+
+
+*    When the `NormalizeURL` function is used (passing an URL object), this source URL object is modified (that is, after the call, the URL object will be modified to reflect the normalization).
+
+*    The *replace IP with domain name* normalization (`http://208.77.188.166/ → http://www.example.com/`) is obviously not possible for a library without making some network requests. This is not implemented in purell.
+
+*    The *remove unused query string parameters* and *remove default query parameters* are also not implemented, since this is a very case-specific normalization, and it is quite trivial to do with an URL object.
+
+### Safe vs Usually Safe vs Unsafe
+
+Purell allows you to control the level of risk you take while normalizing an URL. You can aggressively normalize, play it totally safe, or anything in between.
+
+Consider the following URL:
+
+`HTTPS://www.RooT.com/toto/t%45%1f///a/./b/../c/?z=3&w=2&a=4&w=1#invalid`
+
+Normalizing with the `FlagsSafe` gives:
+
+`https://www.root.com/toto/tE%1F///a/./b/../c/?z=3&w=2&a=4&w=1#invalid`
+
+With the `FlagsUsuallySafeGreedy`:
+
+`https://www.root.com/toto/tE%1F///a/c?z=3&w=2&a=4&w=1#invalid`
+
+And with `FlagsUnsafeGreedy`:
+
+`http://root.com/toto/tE%1F/a/c?a=4&w=1&w=2&z=3`
+
+## TODOs
+
+*    Add a class/default instance to allow specifying custom directory index names? At the moment, removing directory index removes `(^|/)((?:default|index)\.\w{1,4})$`.
+
+## Thanks / Contributions
+
+@rogpeppe
+@jehiah
+@opennota
+@pchristopher1275
+@zenovich
+@beeker1121
+
+## License
+
+The [BSD 3-Clause license][bsd].
+
+[bsd]: http://opensource.org/licenses/BSD-3-Clause
+[wiki]: http://en.wikipedia.org/wiki/URL_normalization
+[rfc]: http://tools.ietf.org/html/rfc3986#section-6
+[godoc]: http://go.pkgdoc.org/github.com/PuerkitoBio/purell
+[pr5]: https://github.com/PuerkitoBio/purell/pull/5
+[iss7]: https://github.com/PuerkitoBio/purell/issues/7
--- a/vendor/github.com/PuerkitoBio/purell/bench_test.go
+++ b/vendor/github.com/PuerkitoBio/purell/bench_test.go
@ -0,0 +1,57 @@
+package purell
+
+import (
+	"testing"
+)
+
+var (
+	safeUrl        = "HttPS://..iaMHost..Test:443/paTh^A%ef//./%41PaTH/..//?"
+	usuallySafeUrl = "HttPS://..iaMHost..Test:443/paTh^A%ef//./%41PaTH/../final/"
+	unsafeUrl      = "HttPS://..www.iaMHost..Test:443/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
+	allDWORDUrl    = "HttPS://1113982867:/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
+	allOctalUrl    = "HttPS://0102.0146.07.0223:/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
+	allHexUrl      = "HttPS://0x42660793:/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
+	allCombinedUrl = "HttPS://..0x42660793.:/paTh^A%ef//./%41PaTH/../final/index.html?t=val1&a=val4&z=val5&a=val1#fragment"
+)
+
+func BenchmarkSafe(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NormalizeURLString(safeUrl, FlagsSafe)
+	}
+}
+
+func BenchmarkUsuallySafe(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NormalizeURLString(usuallySafeUrl, FlagsUsuallySafeGreedy)
+	}
+}
+
+func BenchmarkUnsafe(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NormalizeURLString(unsafeUrl, FlagsUnsafeGreedy)
+	}
+}
+
+func BenchmarkAllDWORD(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NormalizeURLString(allDWORDUrl, FlagsAllGreedy)
+	}
+}
+
+func BenchmarkAllOctal(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NormalizeURLString(allOctalUrl, FlagsAllGreedy)
+	}
+}
+
+func BenchmarkAllHex(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NormalizeURLString(allHexUrl, FlagsAllGreedy)
+	}
+}
+
+func BenchmarkAllCombined(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NormalizeURLString(allCombinedUrl, FlagsAllGreedy)
+	}
+}
--- a/vendor/github.com/PuerkitoBio/purell/benchmarks/v0.1.0
+++ b/vendor/github.com/PuerkitoBio/purell/benchmarks/v0.1.0
@ -0,0 +1,9 @@
+PASS
+BenchmarkSafe	  500000	      6131 ns/op
+BenchmarkUsuallySafe	  200000	      7864 ns/op
+BenchmarkUnsafe	  100000	     28560 ns/op
+BenchmarkAllDWORD	   50000	     38722 ns/op
+BenchmarkAllOctal	   50000	     40941 ns/op
+BenchmarkAllHex	   50000	     44063 ns/op
+BenchmarkAllCombined	   50000	     33613 ns/op
+ok  	github.com/PuerkitoBio/purell	17.404s
--- a/vendor/github.com/PuerkitoBio/purell/example_test.go
+++ b/vendor/github.com/PuerkitoBio/purell/example_test.go
@ -0,0 +1,35 @@
+package purell
+
+import (
+	"fmt"
+	"net/url"
+)
+
+func ExampleNormalizeURLString() {
+	if normalized, err := NormalizeURLString("hTTp://someWEBsite.com:80/Amazing%3f/url/",
+		FlagLowercaseScheme|FlagLowercaseHost|FlagUppercaseEscapes); err != nil {
+		panic(err)
+	} else {
+		fmt.Print(normalized)
+	}
+	// Output: http://somewebsite.com:80/Amazing%3F/url/
+}
+
+func ExampleMustNormalizeURLString() {
+	normalized := MustNormalizeURLString("hTTpS://someWEBsite.com:443/Amazing%fa/url/",
+		FlagsUnsafeGreedy)
+	fmt.Print(normalized)
+
+	// Output: http://somewebsite.com/Amazing%FA/url
+}
+
+func ExampleNormalizeURL() {
+	if u, err := url.Parse("Http://SomeUrl.com:8080/a/b/.././c///g?c=3&a=1&b=9&c=0#target"); err != nil {
+		panic(err)
+	} else {
+		normalized := NormalizeURL(u, FlagsUsuallySafeGreedy|FlagRemoveDuplicateSlashes|FlagRemoveFragment)
+		fmt.Print(normalized)
+	}
+
+	// Output: http://someurl.com:8080/a/c/g?c=3&a=1&b=9&c=0
+}
--- a/vendor/github.com/PuerkitoBio/purell/purell.go
+++ b/vendor/github.com/PuerkitoBio/purell/purell.go
@ -0,0 +1,379 @@
+/*
+Package purell offers URL normalization as described on the wikipedia page:
+http://en.wikipedia.org/wiki/URL_normalization
+*/
+package purell
+
+import (
+	"bytes"
+	"fmt"
+	"net/url"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/PuerkitoBio/urlesc"
+	"golang.org/x/net/idna"
+	"golang.org/x/text/unicode/norm"
+	"golang.org/x/text/width"
+)
+
+// A set of normalization flags determines how a URL will
+// be normalized.
+type NormalizationFlags uint
+
+const (
+	// Safe normalizations
+	FlagLowercaseScheme           NormalizationFlags = 1 << iota // HTTP://host -> http://host, applied by default in Go1.1
+	FlagLowercaseHost                                            // http://HOST -> http://host
+	FlagUppercaseEscapes                                         // http://host/t%ef -> http://host/t%EF
+	FlagDecodeUnnecessaryEscapes                                 // http://host/t%41 -> http://host/tA
+	FlagEncodeNecessaryEscapes                                   // http://host/!"#$ -> http://host/%21%22#$
+	FlagRemoveDefaultPort                                        // http://host:80 -> http://host
+	FlagRemoveEmptyQuerySeparator                                // http://host/path? -> http://host/path
+
+	// Usually safe normalizations
+	FlagRemoveTrailingSlash // http://host/path/ -> http://host/path
+	FlagAddTrailingSlash    // http://host/path -> http://host/path/ (should choose only one of these add/remove trailing slash flags)
+	FlagRemoveDotSegments   // http://host/path/./a/b/../c -> http://host/path/a/c
+
+	// Unsafe normalizations
+	FlagRemoveDirectoryIndex   // http://host/path/index.html -> http://host/path/
+	FlagRemoveFragment         // http://host/path#fragment -> http://host/path
+	FlagForceHTTP              // https://host -> http://host
+	FlagRemoveDuplicateSlashes // http://host/path//a///b -> http://host/path/a/b
+	FlagRemoveWWW              // http://www.host/ -> http://host/
+	FlagAddWWW                 // http://host/ -> http://www.host/ (should choose only one of these add/remove WWW flags)
+	FlagSortQuery              // http://host/path?c=3&b=2&a=1&b=1 -> http://host/path?a=1&b=1&b=2&c=3
+
+	// Normalizations not in the wikipedia article, required to cover tests cases
+	// submitted by jehiah
+	FlagDecodeDWORDHost           // http://1113982867 -> http://66.102.7.147
+	FlagDecodeOctalHost           // http://0102.0146.07.0223 -> http://66.102.7.147
+	FlagDecodeHexHost             // http://0x42660793 -> http://66.102.7.147
+	FlagRemoveUnnecessaryHostDots // http://.host../path -> http://host/path
+	FlagRemoveEmptyPortSeparator  // http://host:/path -> http://host/path
+
+	// Convenience set of safe normalizations
+	FlagsSafe NormalizationFlags = FlagLowercaseHost | FlagLowercaseScheme | FlagUppercaseEscapes | FlagDecodeUnnecessaryEscapes | FlagEncodeNecessaryEscapes | FlagRemoveDefaultPort | FlagRemoveEmptyQuerySeparator
+
+	// For convenience sets, "greedy" uses the "remove trailing slash" and "remove www. prefix" flags,
+	// while "non-greedy" uses the "add (or keep) the trailing slash" and "add www. prefix".
+
+	// Convenience set of usually safe normalizations (includes FlagsSafe)
+	FlagsUsuallySafeGreedy    NormalizationFlags = FlagsSafe | FlagRemoveTrailingSlash | FlagRemoveDotSegments
+	FlagsUsuallySafeNonGreedy NormalizationFlags = FlagsSafe | FlagAddTrailingSlash | FlagRemoveDotSegments
+
+	// Convenience set of unsafe normalizations (includes FlagsUsuallySafe)
+	FlagsUnsafeGreedy    NormalizationFlags = FlagsUsuallySafeGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagRemoveWWW | FlagSortQuery
+	FlagsUnsafeNonGreedy NormalizationFlags = FlagsUsuallySafeNonGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagAddWWW | FlagSortQuery
+
+	// Convenience set of all available flags
+	FlagsAllGreedy    = FlagsUnsafeGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
+	FlagsAllNonGreedy = FlagsUnsafeNonGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
+)
+
+const (
+	defaultHttpPort  = ":80"
+	defaultHttpsPort = ":443"
+)
+
+// Regular expressions used by the normalizations
+var rxPort = regexp.MustCompile(`(:\d+)/?$`)
+var rxDirIndex = regexp.MustCompile(`(^|/)((?:default|index)\.\w{1,4})$`)
+var rxDupSlashes = regexp.MustCompile(`/{2,}`)
+var rxDWORDHost = regexp.MustCompile(`^(\d+)((?:\.+)?(?:\:\d*)?)$`)
+var rxOctalHost = regexp.MustCompile(`^(0\d*)\.(0\d*)\.(0\d*)\.(0\d*)((?:\.+)?(?:\:\d*)?)$`)
+var rxHexHost = regexp.MustCompile(`^0x([0-9A-Fa-f]+)((?:\.+)?(?:\:\d*)?)$`)
+var rxHostDots = regexp.MustCompile(`^(.+?)(:\d+)?$`)
+var rxEmptyPort = regexp.MustCompile(`:+$`)
+
+// Map of flags to implementation function.
+// FlagDecodeUnnecessaryEscapes has no action, since it is done automatically
+// by parsing the string as an URL. Same for FlagUppercaseEscapes and FlagRemoveEmptyQuerySeparator.
+
+// Since maps have undefined traversing order, make a slice of ordered keys
+var flagsOrder = []NormalizationFlags{
+	FlagLowercaseScheme,
+	FlagLowercaseHost,
+	FlagRemoveDefaultPort,
+	FlagRemoveDirectoryIndex,
+	FlagRemoveDotSegments,
+	FlagRemoveFragment,
+	FlagForceHTTP, // Must be after remove default port (because https=443/http=80)
+	FlagRemoveDuplicateSlashes,
+	FlagRemoveWWW,
+	FlagAddWWW,
+	FlagSortQuery,
+	FlagDecodeDWORDHost,
+	FlagDecodeOctalHost,
+	FlagDecodeHexHost,
+	FlagRemoveUnnecessaryHostDots,
+	FlagRemoveEmptyPortSeparator,
+	FlagRemoveTrailingSlash, // These two (add/remove trailing slash) must be last
+	FlagAddTrailingSlash,
+}
+
+// ... and then the map, where order is unimportant
+var flags = map[NormalizationFlags]func(*url.URL){
+	FlagLowercaseScheme:           lowercaseScheme,
+	FlagLowercaseHost:             lowercaseHost,
+	FlagRemoveDefaultPort:         removeDefaultPort,
+	FlagRemoveDirectoryIndex:      removeDirectoryIndex,
+	FlagRemoveDotSegments:         removeDotSegments,
+	FlagRemoveFragment:            removeFragment,
+	FlagForceHTTP:                 forceHTTP,
+	FlagRemoveDuplicateSlashes:    removeDuplicateSlashes,
+	FlagRemoveWWW:                 removeWWW,
+	FlagAddWWW:                    addWWW,
+	FlagSortQuery:                 sortQuery,
+	FlagDecodeDWORDHost:           decodeDWORDHost,
+	FlagDecodeOctalHost:           decodeOctalHost,
+	FlagDecodeHexHost:             decodeHexHost,
+	FlagRemoveUnnecessaryHostDots: removeUnncessaryHostDots,
+	FlagRemoveEmptyPortSeparator:  removeEmptyPortSeparator,
+	FlagRemoveTrailingSlash:       removeTrailingSlash,
+	FlagAddTrailingSlash:          addTrailingSlash,
+}
+
+// MustNormalizeURLString returns the normalized string, and panics if an error occurs.
+// It takes an URL string as input, as well as the normalization flags.
+func MustNormalizeURLString(u string, f NormalizationFlags) string {
+	result, e := NormalizeURLString(u, f)
+	if e != nil {
+		panic(e)
+	}
+	return result
+}
+
+// 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 err != nil {
+		return "", err
+	}
+
+	if f&FlagLowercaseHost == FlagLowercaseHost {
+		parsed.Host = strings.ToLower(parsed.Host)
+	}
+
+	// The idna package doesn't fully conform to RFC 5895
+	// (https://tools.ietf.org/html/rfc5895), so we do it here.
+	// Taken from Go 1.8 cycle source, courtesy of bradfitz.
+	// 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
+}
+
+// NormalizeURL returns the normalized string.
+// It takes a parsed URL object as input, as well as the normalization flags.
+func NormalizeURL(u *url.URL, f NormalizationFlags) string {
+	for _, k := range flagsOrder {
+		if f&k == k {
+			flags[k](u)
+		}
+	}
+	return urlesc.Escape(u)
+}
+
+func lowercaseScheme(u *url.URL) {
+	if len(u.Scheme) > 0 {
+		u.Scheme = strings.ToLower(u.Scheme)
+	}
+}
+
+func lowercaseHost(u *url.URL) {
+	if len(u.Host) > 0 {
+		u.Host = strings.ToLower(u.Host)
+	}
+}
+
+func removeDefaultPort(u *url.URL) {
+	if len(u.Host) > 0 {
+		scheme := strings.ToLower(u.Scheme)
+		u.Host = rxPort.ReplaceAllStringFunc(u.Host, func(val string) string {
+			if (scheme == "http" && val == defaultHttpPort) || (scheme == "https" && val == defaultHttpsPort) {
+				return ""
+			}
+			return val
+		})
+	}
+}
+
+func removeTrailingSlash(u *url.URL) {
+	if l := len(u.Path); l > 0 {
+		if strings.HasSuffix(u.Path, "/") {
+			u.Path = u.Path[:l-1]
+		}
+	} else if l = len(u.Host); l > 0 {
+		if strings.HasSuffix(u.Host, "/") {
+			u.Host = u.Host[:l-1]
+		}
+	}
+}
+
+func addTrailingSlash(u *url.URL) {
+	if l := len(u.Path); l > 0 {
+		if !strings.HasSuffix(u.Path, "/") {
+			u.Path += "/"
+		}
+	} else if l = len(u.Host); l > 0 {
+		if !strings.HasSuffix(u.Host, "/") {
+			u.Host += "/"
+		}
+	}
+}
+
+func removeDotSegments(u *url.URL) {
+	if len(u.Path) > 0 {
+		var dotFree []string
+		var lastIsDot bool
+
+		sections := strings.Split(u.Path, "/")
+		for _, s := range sections {
+			if s == ".." {
+				if len(dotFree) > 0 {
+					dotFree = dotFree[:len(dotFree)-1]
+				}
+			} else if s != "." {
+				dotFree = append(dotFree, s)
+			}
+			lastIsDot = (s == "." || s == "..")
+		}
+		// Special case if host does not end with / and new path does not begin with /
+		u.Path = strings.Join(dotFree, "/")
+		if u.Host != "" && !strings.HasSuffix(u.Host, "/") && !strings.HasPrefix(u.Path, "/") {
+			u.Path = "/" + u.Path
+		}
+		// Special case if the last segment was a dot, make sure the path ends with a slash
+		if lastIsDot && !strings.HasSuffix(u.Path, "/") {
+			u.Path += "/"
+		}
+	}
+}
+
+func removeDirectoryIndex(u *url.URL) {
+	if len(u.Path) > 0 {
+		u.Path = rxDirIndex.ReplaceAllString(u.Path, "$1")
+	}
+}
+
+func removeFragment(u *url.URL) {
+	u.Fragment = ""
+}
+
+func forceHTTP(u *url.URL) {
+	if strings.ToLower(u.Scheme) == "https" {
+		u.Scheme = "http"
+	}
+}
+
+func removeDuplicateSlashes(u *url.URL) {
+	if len(u.Path) > 0 {
+		u.Path = rxDupSlashes.ReplaceAllString(u.Path, "/")
+	}
+}
+
+func removeWWW(u *url.URL) {
+	if len(u.Host) > 0 && strings.HasPrefix(strings.ToLower(u.Host), "www.") {
+		u.Host = u.Host[4:]
+	}
+}
+
+func addWWW(u *url.URL) {
+	if len(u.Host) > 0 && !strings.HasPrefix(strings.ToLower(u.Host), "www.") {
+		u.Host = "www." + u.Host
+	}
+}
+
+func sortQuery(u *url.URL) {
+	q := u.Query()
+
+	if len(q) > 0 {
+		arKeys := make([]string, len(q))
+		i := 0
+		for k, _ := range q {
+			arKeys[i] = k
+			i++
+		}
+		sort.Strings(arKeys)
+		buf := new(bytes.Buffer)
+		for _, k := range arKeys {
+			sort.Strings(q[k])
+			for _, v := range q[k] {
+				if buf.Len() > 0 {
+					buf.WriteRune('&')
+				}
+				buf.WriteString(fmt.Sprintf("%s=%s", k, urlesc.QueryEscape(v)))
+			}
+		}
+
+		// Rebuild the raw query string
+		u.RawQuery = buf.String()
+	}
+}
+
+func decodeDWORDHost(u *url.URL) {
+	if len(u.Host) > 0 {
+		if matches := rxDWORDHost.FindStringSubmatch(u.Host); len(matches) > 2 {
+			var parts [4]int64
+
+			dword, _ := strconv.ParseInt(matches[1], 10, 0)
+			for i, shift := range []uint{24, 16, 8, 0} {
+				parts[i] = dword >> shift & 0xFF
+			}
+			u.Host = fmt.Sprintf("%d.%d.%d.%d%s", parts[0], parts[1], parts[2], parts[3], matches[2])
+		}
+	}
+}
+
+func decodeOctalHost(u *url.URL) {
+	if len(u.Host) > 0 {
+		if matches := rxOctalHost.FindStringSubmatch(u.Host); len(matches) > 5 {
+			var parts [4]int64
+
+			for i := 1; i <= 4; i++ {
+				parts[i-1], _ = strconv.ParseInt(matches[i], 8, 0)
+			}
+			u.Host = fmt.Sprintf("%d.%d.%d.%d%s", parts[0], parts[1], parts[2], parts[3], matches[5])
+		}
+	}
+}
+
+func decodeHexHost(u *url.URL) {
+	if len(u.Host) > 0 {
+		if matches := rxHexHost.FindStringSubmatch(u.Host); len(matches) > 2 {
+			// Conversion is safe because of regex validation
+			parsed, _ := strconv.ParseInt(matches[1], 16, 0)
+			// Set host as DWORD (base 10) encoded host
+			u.Host = fmt.Sprintf("%d%s", parsed, matches[2])
+			// The rest is the same as decoding a DWORD host
+			decodeDWORDHost(u)
+		}
+	}
+}
+
+func removeUnncessaryHostDots(u *url.URL) {
+	if len(u.Host) > 0 {
+		if matches := rxHostDots.FindStringSubmatch(u.Host); len(matches) > 1 {
+			// Trim the leading and trailing dots
+			u.Host = strings.Trim(matches[1], ".")
+			if len(matches) > 2 {
+				u.Host += matches[2]
+			}
+		}
+	}
+}
+
+func removeEmptyPortSeparator(u *url.URL) {
+	if len(u.Host) > 0 {
+		u.Host = rxEmptyPort.ReplaceAllString(u.Host, "")
+	}
+}
--- a/vendor/github.com/PuerkitoBio/purell/purell_test.go
+++ b/vendor/github.com/PuerkitoBio/purell/purell_test.go
@ -0,0 +1,768 @@
+package purell
+
+import (
+	"fmt"
+	"net/url"
+	"testing"
+)
+
+type testCase struct {
+	nm     string
+	src    string
+	flgs   NormalizationFlags
+	res    string
+	parsed bool
+}
+
+var (
+	cases = [...]*testCase{
+		&testCase{
+			"LowerScheme",
+			"HTTP://www.SRC.ca",
+			FlagLowercaseScheme,
+			"http://www.SRC.ca",
+			false,
+		},
+		&testCase{
+			"LowerScheme2",
+			"http://www.SRC.ca",
+			FlagLowercaseScheme,
+			"http://www.SRC.ca",
+			false,
+		},
+		&testCase{
+			"LowerHost",
+			"HTTP://www.SRC.ca/",
+			FlagLowercaseHost,
+			"http://www.src.ca/", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"UpperEscapes",
+			`http://www.whatever.com/Some%aa%20Special%8Ecases/`,
+			FlagUppercaseEscapes,
+			"http://www.whatever.com/Some%AA%20Special%8Ecases/",
+			false,
+		},
+		&testCase{
+			"UnnecessaryEscapes",
+			`http://www.toto.com/%41%42%2E%44/%32%33%52%2D/%5f%7E`,
+			FlagDecodeUnnecessaryEscapes,
+			"http://www.toto.com/AB.D/23R-/_~",
+			false,
+		},
+		&testCase{
+			"RemoveDefaultPort",
+			"HTTP://www.SRC.ca:80/",
+			FlagRemoveDefaultPort,
+			"http://www.SRC.ca/", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"RemoveDefaultPort2",
+			"HTTP://www.SRC.ca:80",
+			FlagRemoveDefaultPort,
+			"http://www.SRC.ca", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"RemoveDefaultPort3",
+			"HTTP://www.SRC.ca:8080",
+			FlagRemoveDefaultPort,
+			"http://www.SRC.ca:8080", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"Safe",
+			"HTTP://www.SRC.ca:80/to%1ato%8b%ee/OKnow%41%42%43%7e",
+			FlagsSafe,
+			"http://www.src.ca/to%1Ato%8B%EE/OKnowABC~",
+			false,
+		},
+		&testCase{
+			"BothLower",
+			"HTTP://www.SRC.ca:80/to%1ato%8b%ee/OKnow%41%42%43%7e",
+			FlagLowercaseHost | FlagLowercaseScheme,
+			"http://www.src.ca:80/to%1Ato%8B%EE/OKnowABC~",
+			false,
+		},
+		&testCase{
+			"RemoveTrailingSlash",
+			"HTTP://www.SRC.ca:80/",
+			FlagRemoveTrailingSlash,
+			"http://www.SRC.ca:80", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"RemoveTrailingSlash2",
+			"HTTP://www.SRC.ca:80/toto/titi/",
+			FlagRemoveTrailingSlash,
+			"http://www.SRC.ca:80/toto/titi", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"RemoveTrailingSlash3",
+			"HTTP://www.SRC.ca:80/toto/titi/fin/?a=1",
+			FlagRemoveTrailingSlash,
+			"http://www.SRC.ca:80/toto/titi/fin?a=1", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"AddTrailingSlash",
+			"HTTP://www.SRC.ca:80",
+			FlagAddTrailingSlash,
+			"http://www.SRC.ca:80/", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"AddTrailingSlash2",
+			"HTTP://www.SRC.ca:80/toto/titi.html",
+			FlagAddTrailingSlash,
+			"http://www.SRC.ca:80/toto/titi.html/", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"AddTrailingSlash3",
+			"HTTP://www.SRC.ca:80/toto/titi/fin?a=1",
+			FlagAddTrailingSlash,
+			"http://www.SRC.ca:80/toto/titi/fin/?a=1", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"RemoveDotSegments",
+			"HTTP://root/a/b/./../../c/",
+			FlagRemoveDotSegments,
+			"http://root/c/", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"RemoveDotSegments2",
+			"HTTP://root/../a/b/./../c/../d",
+			FlagRemoveDotSegments,
+			"http://root/a/d", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"UsuallySafe",
+			"HTTP://www.SRC.ca:80/to%1ato%8b%ee/./c/d/../OKnow%41%42%43%7e/?a=b#test",
+			FlagsUsuallySafeGreedy,
+			"http://www.src.ca/to%1Ato%8B%EE/c/OKnowABC~?a=b#test",
+			false,
+		},
+		&testCase{
+			"RemoveDirectoryIndex",
+			"HTTP://root/a/b/c/default.aspx",
+			FlagRemoveDirectoryIndex,
+			"http://root/a/b/c/", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"RemoveDirectoryIndex2",
+			"HTTP://root/a/b/c/default#a=b",
+			FlagRemoveDirectoryIndex,
+			"http://root/a/b/c/default#a=b", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"RemoveFragment",
+			"HTTP://root/a/b/c/default#toto=tata",
+			FlagRemoveFragment,
+			"http://root/a/b/c/default", // Since Go1.1, scheme is automatically lowercased
+			false,
+		},
+		&testCase{
+			"ForceHTTP",
+			"https://root/a/b/c/default#toto=tata",
+			FlagForceHTTP,
+			"http://root/a/b/c/default#toto=tata",
+			false,
+		},
+		&testCase{
+			"RemoveDuplicateSlashes",
+			"https://root/a//b///c////default#toto=tata",
+			FlagRemoveDuplicateSlashes,
+			"https://root/a/b/c/default#toto=tata",
+			false,
+		},
+		&testCase{
+			"RemoveDuplicateSlashes2",
+			"https://root//a//b///c////default#toto=tata",
+			FlagRemoveDuplicateSlashes,
+			"https://root/a/b/c/default#toto=tata",
+			false,
+		},
+		&testCase{
+			"RemoveWWW",
+			"https://www.root/a/b/c/",
+			FlagRemoveWWW,
+			"https://root/a/b/c/",
+			false,
+		},
+		&testCase{
+			"RemoveWWW2",
+			"https://WwW.Root/a/b/c/",
+			FlagRemoveWWW,
+			"https://Root/a/b/c/",
+			false,
+		},
+		&testCase{
+			"AddWWW",
+			"https://Root/a/b/c/",
+			FlagAddWWW,
+			"https://www.Root/a/b/c/",
+			false,
+		},
+		&testCase{
+			"SortQuery",
+			"http://root/toto/?b=4&a=1&c=3&b=2&a=5",
+			FlagSortQuery,
+			"http://root/toto/?a=1&a=5&b=2&b=4&c=3",
+			false,
+		},
+		&testCase{
+			"RemoveEmptyQuerySeparator",
+			"http://root/toto/?",
+			FlagRemoveEmptyQuerySeparator,
+			"http://root/toto/",
+			false,
+		},
+		&testCase{
+			"Unsafe",
+			"HTTPS://www.RooT.com/toto/t%45%1f///a/./b/../c/?z=3&w=2&a=4&w=1#invalid",
+			FlagsUnsafeGreedy,
+			"http://root.com/toto/tE%1F/a/c?a=4&w=1&w=2&z=3",
+			false,
+		},
+		&testCase{
+			"Safe2",
+			"HTTPS://www.RooT.com/toto/t%45%1f///a/./b/../c/?z=3&w=2&a=4&w=1#invalid",
+			FlagsSafe,
+			"https://www.root.com/toto/tE%1F///a/./b/../c/?z=3&w=2&a=4&w=1#invalid",
+			false,
+		},
+		&testCase{
+			"UsuallySafe2",
+			"HTTPS://www.RooT.com/toto/t%45%1f///a/./b/../c/?z=3&w=2&a=4&w=1#invalid",
+			FlagsUsuallySafeGreedy,
+			"https://www.root.com/toto/tE%1F///a/c?z=3&w=2&a=4&w=1#invalid",
+			false,
+		},
+		&testCase{
+			"AddTrailingSlashBug",
+			"http://src.ca/",
+			FlagsAllNonGreedy,
+			"http://www.src.ca/",
+			false,
+		},
+		&testCase{
+			"SourceModified",
+			"HTTPS://www.RooT.com/toto/t%45%1f///a/./b/../c/?z=3&w=2&a=4&w=1#invalid",
+			FlagsUnsafeGreedy,
+			"http://root.com/toto/tE%1F/a/c?a=4&w=1&w=2&z=3",
+			true,
+		},
+		&testCase{
+			"IPv6-1",
+			"http://[2001:db8:1f70::999:de8:7648:6e8]/test",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://[2001:db8:1f70::999:de8:7648:6e8]/test",
+			false,
+		},
+		&testCase{
+			"IPv6-2",
+			"http://[::ffff:192.168.1.1]/test",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://[::ffff:192.168.1.1]/test",
+			false,
+		},
+		&testCase{
+			"IPv6-3",
+			"http://[::ffff:192.168.1.1]:80/test",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://[::ffff:192.168.1.1]/test",
+			false,
+		},
+		&testCase{
+			"IPv6-4",
+			"htTps://[::fFff:192.168.1.1]:443/test",
+			FlagsSafe | FlagRemoveDotSegments,
+			"https://[::ffff:192.168.1.1]/test",
+			false,
+		},
+		&testCase{
+			"FTP",
+			"ftp://user:pass@ftp.foo.net/foo/bar",
+			FlagsSafe | FlagRemoveDotSegments,
+			"ftp://user:pass@ftp.foo.net/foo/bar",
+			false,
+		},
+		&testCase{
+			"Standard-1",
+			"http://www.foo.com:80/foo",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://www.foo.com/foo",
+			false,
+		},
+		&testCase{
+			"Standard-2",
+			"http://www.foo.com:8000/foo",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://www.foo.com:8000/foo",
+			false,
+		},
+		&testCase{
+			"Standard-3",
+			"http://www.foo.com/%7ebar",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://www.foo.com/~bar",
+			false,
+		},
+		&testCase{
+			"Standard-4",
+			"http://www.foo.com/%7Ebar",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://www.foo.com/~bar",
+			false,
+		},
+		&testCase{
+			"Standard-5",
+			"http://USER:pass@www.Example.COM/foo/bar",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://USER:pass@www.example.com/foo/bar",
+			false,
+		},
+		&testCase{
+			"Standard-6",
+			"http://test.example/?a=%26&b=1",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://test.example/?a=%26&b=1",
+			false,
+		},
+		&testCase{
+			"Standard-7",
+			"http://test.example/%25/?p=%20val%20%25",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://test.example/%25/?p=%20val%20%25",
+			false,
+		},
+		&testCase{
+			"Standard-8",
+			"http://test.example/path/with a%20space+/",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://test.example/path/with%20a%20space+/",
+			false,
+		},
+		&testCase{
+			"Standard-9",
+			"http://test.example/?",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://test.example/",
+			false,
+		},
+		&testCase{
+			"Standard-10",
+			"http://a.COM/path/?b&a",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://a.com/path/?b&a",
+			false,
+		},
+		&testCase{
+			"StandardCasesAddTrailingSlash",
+			"http://test.example?",
+			FlagsSafe | FlagAddTrailingSlash,
+			"http://test.example/",
+			false,
+		},
+		&testCase{
+			"OctalIP-1",
+			"http://0123.011.0.4/",
+			FlagsSafe | FlagDecodeOctalHost,
+			"http://0123.011.0.4/",
+			false,
+		},
+		&testCase{
+			"OctalIP-2",
+			"http://0102.0146.07.0223/",
+			FlagsSafe | FlagDecodeOctalHost,
+			"http://66.102.7.147/",
+			false,
+		},
+		&testCase{
+			"OctalIP-3",
+			"http://0102.0146.07.0223.:23/",
+			FlagsSafe | FlagDecodeOctalHost,
+			"http://66.102.7.147.:23/",
+			false,
+		},
+		&testCase{
+			"OctalIP-4",
+			"http://USER:pass@0102.0146.07.0223../",
+			FlagsSafe | FlagDecodeOctalHost,
+			"http://USER:pass@66.102.7.147../",
+			false,
+		},
+		&testCase{
+			"DWORDIP-1",
+			"http://123.1113982867/",
+			FlagsSafe | FlagDecodeDWORDHost,
+			"http://123.1113982867/",
+			false,
+		},
+		&testCase{
+			"DWORDIP-2",
+			"http://1113982867/",
+			FlagsSafe | FlagDecodeDWORDHost,
+			"http://66.102.7.147/",
+			false,
+		},
+		&testCase{
+			"DWORDIP-3",
+			"http://1113982867.:23/",
+			FlagsSafe | FlagDecodeDWORDHost,
+			"http://66.102.7.147.:23/",
+			false,
+		},
+		&testCase{
+			"DWORDIP-4",
+			"http://USER:pass@1113982867../",
+			FlagsSafe | FlagDecodeDWORDHost,
+			"http://USER:pass@66.102.7.147../",
+			false,
+		},
+		&testCase{
+			"HexIP-1",
+			"http://0x123.1113982867/",
+			FlagsSafe | FlagDecodeHexHost,
+			"http://0x123.1113982867/",
+			false,
+		},
+		&testCase{
+			"HexIP-2",
+			"http://0x42660793/",
+			FlagsSafe | FlagDecodeHexHost,
+			"http://66.102.7.147/",
+			false,
+		},
+		&testCase{
+			"HexIP-3",
+			"http://0x42660793.:23/",
+			FlagsSafe | FlagDecodeHexHost,
+			"http://66.102.7.147.:23/",
+			false,
+		},
+		&testCase{
+			"HexIP-4",
+			"http://USER:pass@0x42660793../",
+			FlagsSafe | FlagDecodeHexHost,
+			"http://USER:pass@66.102.7.147../",
+			false,
+		},
+		&testCase{
+			"UnnecessaryHostDots-1",
+			"http://.www.foo.com../foo/bar.html",
+			FlagsSafe | FlagRemoveUnnecessaryHostDots,
+			"http://www.foo.com/foo/bar.html",
+			false,
+		},
+		&testCase{
+			"UnnecessaryHostDots-2",
+			"http://www.foo.com./foo/bar.html",
+			FlagsSafe | FlagRemoveUnnecessaryHostDots,
+			"http://www.foo.com/foo/bar.html",
+			false,
+		},
+		&testCase{
+			"UnnecessaryHostDots-3",
+			"http://www.foo.com.:81/foo",
+			FlagsSafe | FlagRemoveUnnecessaryHostDots,
+			"http://www.foo.com:81/foo",
+			false,
+		},
+		&testCase{
+			"UnnecessaryHostDots-4",
+			"http://www.example.com./",
+			FlagsSafe | FlagRemoveUnnecessaryHostDots,
+			"http://www.example.com/",
+			false,
+		},
+		&testCase{
+			"EmptyPort-1",
+			"http://www.thedraymin.co.uk:/main/?p=308",
+			FlagsSafe | FlagRemoveEmptyPortSeparator,
+			"http://www.thedraymin.co.uk/main/?p=308",
+			false,
+		},
+		&testCase{
+			"EmptyPort-2",
+			"http://www.src.ca:",
+			FlagsSafe | FlagRemoveEmptyPortSeparator,
+			"http://www.src.ca",
+			false,
+		},
+		&testCase{
+			"Slashes-1",
+			"http://test.example/foo/bar/.",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo/bar/",
+			false,
+		},
+		&testCase{
+			"Slashes-2",
+			"http://test.example/foo/bar/./",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo/bar/",
+			false,
+		},
+		&testCase{
+			"Slashes-3",
+			"http://test.example/foo/bar/..",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo/",
+			false,
+		},
+		&testCase{
+			"Slashes-4",
+			"http://test.example/foo/bar/../",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo/",
+			false,
+		},
+		&testCase{
+			"Slashes-5",
+			"http://test.example/foo/bar/../baz",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo/baz",
+			false,
+		},
+		&testCase{
+			"Slashes-6",
+			"http://test.example/foo/bar/../..",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/",
+			false,
+		},
+		&testCase{
+			"Slashes-7",
+			"http://test.example/foo/bar/../../",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/",
+			false,
+		},
+		&testCase{
+			"Slashes-8",
+			"http://test.example/foo/bar/../../baz",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/baz",
+			false,
+		},
+		&testCase{
+			"Slashes-9",
+			"http://test.example/foo/bar/../../../baz",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/baz",
+			false,
+		},
+		&testCase{
+			"Slashes-10",
+			"http://test.example/foo/bar/../../../../baz",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/baz",
+			false,
+		},
+		&testCase{
+			"Slashes-11",
+			"http://test.example/./foo",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo",
+			false,
+		},
+		&testCase{
+			"Slashes-12",
+			"http://test.example/../foo",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo",
+			false,
+		},
+		&testCase{
+			"Slashes-13",
+			"http://test.example/foo.",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo.",
+			false,
+		},
+		&testCase{
+			"Slashes-14",
+			"http://test.example/.foo",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/.foo",
+			false,
+		},
+		&testCase{
+			"Slashes-15",
+			"http://test.example/foo..",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo..",
+			false,
+		},
+		&testCase{
+			"Slashes-16",
+			"http://test.example/..foo",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/..foo",
+			false,
+		},
+		&testCase{
+			"Slashes-17",
+			"http://test.example/./../foo",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo",
+			false,
+		},
+		&testCase{
+			"Slashes-18",
+			"http://test.example/./foo/.",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo/",
+			false,
+		},
+		&testCase{
+			"Slashes-19",
+			"http://test.example/foo/./bar",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo/bar",
+			false,
+		},
+		&testCase{
+			"Slashes-20",
+			"http://test.example/foo/../bar",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/bar",
+			false,
+		},
+		&testCase{
+			"Slashes-21",
+			"http://test.example/foo//",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo/",
+			false,
+		},
+		&testCase{
+			"Slashes-22",
+			"http://test.example/foo///bar//",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"http://test.example/foo/bar/",
+			false,
+		},
+		&testCase{
+			"Relative",
+			"foo/bar",
+			FlagsAllGreedy,
+			"foo/bar",
+			false,
+		},
+		&testCase{
+			"Relative-1",
+			"./../foo",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"foo",
+			false,
+		},
+		&testCase{
+			"Relative-2",
+			"./foo/bar/../baz/../bang/..",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"foo/",
+			false,
+		},
+		&testCase{
+			"Relative-3",
+			"foo///bar//",
+			FlagsSafe | FlagRemoveDotSegments | FlagRemoveDuplicateSlashes,
+			"foo/bar/",
+			false,
+		},
+		&testCase{
+			"Relative-4",
+			"www.youtube.com",
+			FlagsUsuallySafeGreedy,
+			"www.youtube.com",
+			false,
+		},
+		/*&testCase{
+			"UrlNorm-5",
+			"http://ja.wikipedia.org/wiki/%E3%82%AD%E3%83%A3%E3%82%BF%E3%83%94%E3%83%A9%E3%83%BC%E3%82%B8%E3%83%A3%E3%83%91%E3%83%B3",
+			FlagsSafe | FlagRemoveDotSegments,
+			"http://ja.wikipedia.org/wiki/\xe3\x82\xad\xe3\x83\xa3\xe3\x82\xbf\xe3\x83\x94\xe3\x83\xa9\xe3\x83\xbc\xe3\x82\xb8\xe3\x83\xa3\xe3\x83\x91\xe3\x83\xb3",
+			false,
+		},
+		&testCase{
+			"UrlNorm-1",
+			"http://test.example/?a=%e3%82%82%26",
+			FlagsAllGreedy,
+			"http://test.example/?a=\xe3\x82\x82%26",
+			false,
+		},*/
+	}
+)
+
+func TestRunner(t *testing.T) {
+	for _, tc := range cases {
+		runCase(tc, t)
+	}
+}
+
+func runCase(tc *testCase, t *testing.T) {
+	t.Logf("running %s...", tc.nm)
+	if tc.parsed {
+		u, e := url.Parse(tc.src)
+		if e != nil {
+			t.Errorf("%s - FAIL : %s", tc.nm, e)
+			return
+		} else {
+			NormalizeURL(u, tc.flgs)
+			if s := u.String(); s != tc.res {
+				t.Errorf("%s - FAIL expected '%s', got '%s'", tc.nm, tc.res, s)
+			}
+		}
+	} else {
+		if s, e := NormalizeURLString(tc.src, tc.flgs); e != nil {
+			t.Errorf("%s - FAIL : %s", tc.nm, e)
+		} else if s != tc.res {
+			t.Errorf("%s - FAIL expected '%s', got '%s'", tc.nm, tc.res, s)
+		}
+	}
+}
+
+func TestDecodeUnnecessaryEscapesAll(t *testing.T) {
+	var url = "http://host/"
+
+	for i := 0; i < 256; i++ {
+		url += fmt.Sprintf("%%%02x", i)
+	}
+	if s, e := NormalizeURLString(url, FlagDecodeUnnecessaryEscapes); e != nil {
+		t.Fatalf("Got error %s", e.Error())
+	} else {
+		const want = "http://host/%00%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20!%22%23$%25&'()*+,-./0123456789:;%3C=%3E%3F@ABCDEFGHIJKLMNOPQRSTUVWXYZ[%5C]%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D~%7F%80%81%82%83%84%85%86%87%88%89%8A%8B%8C%8D%8E%8F%90%91%92%93%94%95%96%97%98%99%9A%9B%9C%9D%9E%9F%A0%A1%A2%A3%A4%A5%A6%A7%A8%A9%AA%AB%AC%AD%AE%AF%B0%B1%B2%B3%B4%B5%B6%B7%B8%B9%BA%BB%BC%BD%BE%BF%C0%C1%C2%C3%C4%C5%C6%C7%C8%C9%CA%CB%CC%CD%CE%CF%D0%D1%D2%D3%D4%D5%D6%D7%D8%D9%DA%DB%DC%DD%DE%DF%E0%E1%E2%E3%E4%E5%E6%E7%E8%E9%EA%EB%EC%ED%EE%EF%F0%F1%F2%F3%F4%F5%F6%F7%F8%F9%FA%FB%FC%FD%FE%FF"
+		if s != want {
+			t.Errorf("DecodeUnnecessaryEscapesAll:\nwant\n%s\ngot\n%s", want, s)
+		}
+	}
+}
+
+func TestEncodeNecessaryEscapesAll(t *testing.T) {
+	var url = "http://host/"
+
+	for i := 0; i < 256; i++ {
+		if i != 0x25 {
+			url += string(i)
+		}
+	}
+	if s, e := NormalizeURLString(url, FlagEncodeNecessaryEscapes); e != nil {
+		t.Fatalf("Got error %s", e.Error())
+	} else {
+		const want = "http://host/%00%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20!%22#$&'()*+,-./0123456789:;%3C=%3E?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[%5C]%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D~%7F%C2%80%C2%81%C2%82%C2%83%C2%84%C2%85%C2%86%C2%87%C2%88%C2%89%C2%8A%C2%8B%C2%8C%C2%8D%C2%8E%C2%8F%C2%90%C2%91%C2%92%C2%93%C2%94%C2%95%C2%96%C2%97%C2%98%C2%99%C2%9A%C2%9B%C2%9C%C2%9D%C2%9E%C2%9F%C2%A0%C2%A1%C2%A2%C2%A3%C2%A4%C2%A5%C2%A6%C2%A7%C2%A8%C2%A9%C2%AA%C2%AB%C2%AC%C2%AD%C2%AE%C2%AF%C2%B0%C2%B1%C2%B2%C2%B3%C2%B4%C2%B5%C2%B6%C2%B7%C2%B8%C2%B9%C2%BA%C2%BB%C2%BC%C2%BD%C2%BE%C2%BF%C3%80%C3%81%C3%82%C3%83%C3%84%C3%85%C3%86%C3%87%C3%88%C3%89%C3%8A%C3%8B%C3%8C%C3%8D%C3%8E%C3%8F%C3%90%C3%91%C3%92%C3%93%C3%94%C3%95%C3%96%C3%97%C3%98%C3%99%C3%9A%C3%9B%C3%9C%C3%9D%C3%9E%C3%9F%C3%A0%C3%A1%C3%A2%C3%A3%C3%A4%C3%A5%C3%A6%C3%A7%C3%A8%C3%A9%C3%AA%C3%AB%C3%AC%C3%AD%C3%AE%C3%AF%C3%B0%C3%B1%C3%B2%C3%B3%C3%B4%C3%B5%C3%B6%C3%B7%C3%B8%C3%B9%C3%BA%C3%BB%C3%BC%C3%BD%C3%BE%C3%BF"
+		if s != want {
+			t.Errorf("EncodeNecessaryEscapesAll:\nwant\n%s\ngot\n%s", want, s)
+		}
+	}
+}
--- a/vendor/github.com/PuerkitoBio/purell/urlnorm_test.go
+++ b/vendor/github.com/PuerkitoBio/purell/urlnorm_test.go
@ -0,0 +1,53 @@
+package purell
+
+import (
+	"testing"
+)
+
+// Test cases merged from PR #1
+// Originally from https://github.com/jehiah/urlnorm/blob/master/test_urlnorm.py
+
+func assertMap(t *testing.T, cases map[string]string, f NormalizationFlags) {
+	for bad, good := range cases {
+		s, e := NormalizeURLString(bad, f)
+		if e != nil {
+			t.Errorf("%s normalizing %v to %v", e.Error(), bad, good)
+		} else {
+			if s != good {
+				t.Errorf("source: %v expected: %v got: %v", bad, good, s)
+			}
+		}
+	}
+}
+
+// This tests normalization to a unicode representation
+// precent escapes for unreserved values are unescaped to their unicode value
+// tests normalization to idna domains
+// test ip word handling, ipv6 address handling, and trailing domain periods
+// in general, this matches google chromes unescaping for things in the address bar.
+// spaces are converted to '+' (perhaphs controversial)
+// http://code.google.com/p/google-url/ probably is another good reference for this approach
+func TestUrlnorm(t *testing.T) {
+	testcases := map[string]string{
+		"http://test.example/?a=%e3%82%82%26": "http://test.example/?a=%e3%82%82%26",
+		//"http://test.example/?a=%e3%82%82%26": "http://test.example/?a=\xe3\x82\x82%26", //should return a unicode character
+		"http://s.xn--q-bga.DE/":    "http://s.xn--q-bga.de/",       //should be in idna format
+		"http://XBLA\u306eXbox.com": "http://xn--xblaxbox-jf4g.com", //test utf8 and unicode
+		"http://президент.рф":       "http://xn--d1abbgf6aiiy.xn--p1ai",
+		"http://ПРЕЗИДЕНТ.РФ":       "http://xn--d1abbgf6aiiy.xn--p1ai",
+		"http://ａｂ￥ヲ￦○.com":         "http://xn--ab-ida8983azmfnvs.com", //test width folding
+		"http://\u00e9.com":         "http://xn--9ca.com",
+		"http://e\u0301.com":        "http://xn--9ca.com",
+		"http://ja.wikipedia.org/wiki/%E3%82%AD%E3%83%A3%E3%82%BF%E3%83%94%E3%83%A9%E3%83%BC%E3%82%B8%E3%83%A3%E3%83%91%E3%83%B3": "http://ja.wikipedia.org/wiki/%E3%82%AD%E3%83%A3%E3%82%BF%E3%83%94%E3%83%A9%E3%83%BC%E3%82%B8%E3%83%A3%E3%83%91%E3%83%B3",
+		//"http://ja.wikipedia.org/wiki/%E3%82%AD%E3%83%A3%E3%82%BF%E3%83%94%E3%83%A9%E3%83%BC%E3%82%B8%E3%83%A3%E3%83%91%E3%83%B3": "http://ja.wikipedia.org/wiki/\xe3\x82\xad\xe3\x83\xa3\xe3\x82\xbf\xe3\x83\x94\xe3\x83\xa9\xe3\x83\xbc\xe3\x82\xb8\xe3\x83\xa3\xe3\x83\x91\xe3\x83\xb3",
+
+		"http://test.example/\xe3\x82\xad": "http://test.example/%E3%82%AD",
+		//"http://test.example/\xe3\x82\xad":              "http://test.example/\xe3\x82\xad",
+		"http://test.example/?p=%23val#test-%23-val%25": "http://test.example/?p=%23val#test-%23-val%25", //check that %23 (#) is not escaped where it shouldn't be
+
+		"http://test.domain/I%C3%B1t%C3%ABrn%C3%A2ti%C3%B4n%EF%BF%BDliz%C3%A6ti%C3%B8n": "http://test.domain/I%C3%B1t%C3%ABrn%C3%A2ti%C3%B4n%EF%BF%BDliz%C3%A6ti%C3%B8n",
+		//"http://test.domain/I%C3%B1t%C3%ABrn%C3%A2ti%C3%B4n%EF%BF%BDliz%C3%A6ti%C3%B8n": "http://test.domain/I\xc3\xb1t\xc3\xabrn\xc3\xa2ti\xc3\xb4n\xef\xbf\xbdliz\xc3\xa6ti\xc3\xb8n",
+	}
+
+	assertMap(t, testcases, FlagsSafe|FlagRemoveDotSegments)
+}
--- a/vendor/github.com/PuerkitoBio/urlesc/.travis.yml
+++ b/vendor/github.com/PuerkitoBio/urlesc/.travis.yml
@ -0,0 +1,15 @@
+language: go
+
+go:
+  - 1.4.x
+  - 1.5.x
+  - 1.6.x
+  - 1.7.x
+  - 1.8.x
+  - tip
+
+install:
+  - go build .
+
+script:
+  - go test -v
--- a/vendor/github.com/PuerkitoBio/urlesc/LICENSE
+++ b/vendor/github.com/PuerkitoBio/urlesc/LICENSE
@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/vendor/github.com/PuerkitoBio/urlesc/README.md
+++ b/vendor/github.com/PuerkitoBio/urlesc/README.md
@ -0,0 +1,16 @@
+urlesc [![Build Status](https://travis-ci.org/PuerkitoBio/urlesc.svg?branch=master)](https://travis-ci.org/PuerkitoBio/urlesc) [![GoDoc](http://godoc.org/github.com/PuerkitoBio/urlesc?status.svg)](http://godoc.org/github.com/PuerkitoBio/urlesc)
+======
+
+Package urlesc implements query escaping as per RFC 3986.
+
+It contains some parts of the net/url package, modified so as to allow
+some reserved characters incorrectly escaped by net/url (see [issue 5684](https://github.com/golang/go/issues/5684)).
+
+## Install
+
+    go get github.com/PuerkitoBio/urlesc
+
+## License
+
+Go license (BSD-3-Clause)
+
--- a/vendor/github.com/PuerkitoBio/urlesc/urlesc.go
+++ b/vendor/github.com/PuerkitoBio/urlesc/urlesc.go
@ -0,0 +1,180 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package urlesc implements query escaping as per RFC 3986.
+// It contains some parts of the net/url package, modified so as to allow
+// some reserved characters incorrectly escaped by net/url.
+// See https://github.com/golang/go/issues/5684
+package urlesc
+
+import (
+	"bytes"
+	"net/url"
+	"strings"
+)
+
+type encoding int
+
+const (
+	encodePath encoding = 1 + iota
+	encodeUserPassword
+	encodeQueryComponent
+	encodeFragment
+)
+
+// Return true if the specified character should be escaped when
+// appearing in a URL string, according to RFC 3986.
+func shouldEscape(c byte, mode encoding) bool {
+	// §2.3 Unreserved characters (alphanum)
+	if 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' {
+		return false
+	}
+
+	switch c {
+	case '-', '.', '_', '~': // §2.3 Unreserved characters (mark)
+		return false
+
+	// §2.2 Reserved characters (reserved)
+	case ':', '/', '?', '#', '[', ']', '@', // gen-delims
+		'!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=': // sub-delims
+		// Different sections of the URL allow a few of
+		// the reserved characters to appear unescaped.
+		switch mode {
+		case encodePath: // §3.3
+			// The RFC allows sub-delims and : @.
+			// '/', '[' and ']' can be used to assign meaning to individual path
+			// segments.  This package only manipulates the path as a whole,
+			// so we allow those as well.  That leaves only ? and # to escape.
+			return c == '?' || c == '#'
+
+		case encodeUserPassword: // §3.2.1
+			// The RFC allows : and sub-delims in
+			// userinfo.  The parsing of userinfo treats ':' as special so we must escape
+			// all the gen-delims.
+			return c == ':' || c == '/' || c == '?' || c == '#' || c == '[' || c == ']' || c == '@'
+
+		case encodeQueryComponent: // §3.4
+			// The RFC allows / and ?.
+			return c != '/' && c != '?'
+
+		case encodeFragment: // §4.1
+			// The RFC text is silent but the grammar allows
+			// everything, so escape nothing but #
+			return c == '#'
+		}
+	}
+
+	// Everything else must be escaped.
+	return true
+}
+
+// QueryEscape escapes the string so it can be safely placed
+// inside a URL query.
+func QueryEscape(s string) string {
+	return escape(s, encodeQueryComponent)
+}
+
+func escape(s string, mode encoding) string {
+	spaceCount, hexCount := 0, 0
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if shouldEscape(c, mode) {
+			if c == ' ' && mode == encodeQueryComponent {
+				spaceCount++
+			} else {
+				hexCount++
+			}
+		}
+	}
+
+	if spaceCount == 0 && hexCount == 0 {
+		return s
+	}
+
+	t := make([]byte, len(s)+2*hexCount)
+	j := 0
+	for i := 0; i < len(s); i++ {
+		switch c := s[i]; {
+		case c == ' ' && mode == encodeQueryComponent:
+			t[j] = '+'
+			j++
+		case shouldEscape(c, mode):
+			t[j] = '%'
+			t[j+1] = "0123456789ABCDEF"[c>>4]
+			t[j+2] = "0123456789ABCDEF"[c&15]
+			j += 3
+		default:
+			t[j] = s[i]
+			j++
+		}
+	}
+	return string(t)
+}
+
+var uiReplacer = strings.NewReplacer(
+	"%21", "!",
+	"%27", "'",
+	"%28", "(",
+	"%29", ")",
+	"%2A", "*",
+)
+
+// unescapeUserinfo unescapes some characters that need not to be escaped as per RFC3986.
+func unescapeUserinfo(s string) string {
+	return uiReplacer.Replace(s)
+}
+
+// Escape reassembles the URL into a valid URL string.
+// The general form of the result is one of:
+//
+//	scheme:opaque
+//	scheme://userinfo@host/path?query#fragment
+//
+// If u.Opaque is non-empty, String uses the first form;
+// otherwise it uses the second form.
+//
+// In the second form, the following rules apply:
+//	- if u.Scheme is empty, scheme: is omitted.
+//	- if u.User is nil, userinfo@ is omitted.
+//	- if u.Host is empty, host/ is omitted.
+//	- if u.Scheme and u.Host are empty and u.User is nil,
+//	   the entire scheme://userinfo@host/ is omitted.
+//	- if u.Host is non-empty and u.Path begins with a /,
+//	   the form host/path does not add its own /.
+//	- if u.RawQuery is empty, ?query is omitted.
+//	- if u.Fragment is empty, #fragment is omitted.
+func Escape(u *url.URL) string {
+	var buf bytes.Buffer
+	if u.Scheme != "" {
+		buf.WriteString(u.Scheme)
+		buf.WriteByte(':')
+	}
+	if u.Opaque != "" {
+		buf.WriteString(u.Opaque)
+	} else {
+		if u.Scheme != "" || u.Host != "" || u.User != nil {
+			buf.WriteString("//")
+			if ui := u.User; ui != nil {
+				buf.WriteString(unescapeUserinfo(ui.String()))
+				buf.WriteByte('@')
+			}
+			if h := u.Host; h != "" {
+				buf.WriteString(h)
+			}
+		}
+		if u.Path != "" && u.Path[0] != '/' && u.Host != "" {
+			buf.WriteByte('/')
+		}
+		buf.WriteString(escape(u.Path, encodePath))
+	}
+	if u.RawQuery != "" {
+		buf.WriteByte('?')
+		buf.WriteString(u.RawQuery)
+	}
+	if u.Fragment != "" {
+		buf.WriteByte('#')
+		buf.WriteString(escape(u.Fragment, encodeFragment))
+	}
+	return buf.String()
+}
--- a/vendor/github.com/PuerkitoBio/urlesc/urlesc_test.go
+++ b/vendor/github.com/PuerkitoBio/urlesc/urlesc_test.go
@ -0,0 +1,641 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package urlesc
+
+import (
+	"net/url"
+	"testing"
+)
+
+type URLTest struct {
+	in        string
+	out       *url.URL
+	roundtrip string // expected result of reserializing the URL; empty means same as "in".
+}
+
+var urltests = []URLTest{
+	// no path
+	{
+		"http://www.google.com",
+		&url.URL{
+			Scheme: "http",
+			Host:   "www.google.com",
+		},
+		"",
+	},
+	// path
+	{
+		"http://www.google.com/",
+		&url.URL{
+			Scheme: "http",
+			Host:   "www.google.com",
+			Path:   "/",
+		},
+		"",
+	},
+	// path with hex escaping
+	{
+		"http://www.google.com/file%20one%26two",
+		&url.URL{
+			Scheme: "http",
+			Host:   "www.google.com",
+			Path:   "/file one&two",
+		},
+		"http://www.google.com/file%20one&two",
+	},
+	// user
+	{
+		"ftp://webmaster@www.google.com/",
+		&url.URL{
+			Scheme: "ftp",
+			User:   url.User("webmaster"),
+			Host:   "www.google.com",
+			Path:   "/",
+		},
+		"",
+	},
+	// escape sequence in username
+	{
+		"ftp://john%20doe@www.google.com/",
+		&url.URL{
+			Scheme: "ftp",
+			User:   url.User("john doe"),
+			Host:   "www.google.com",
+			Path:   "/",
+		},
+		"ftp://john%20doe@www.google.com/",
+	},
+	// query
+	{
+		"http://www.google.com/?q=go+language",
+		&url.URL{
+			Scheme:   "http",
+			Host:     "www.google.com",
+			Path:     "/",
+			RawQuery: "q=go+language",
+		},
+		"",
+	},
+	// query with hex escaping: NOT parsed
+	{
+		"http://www.google.com/?q=go%20language",
+		&url.URL{
+			Scheme:   "http",
+			Host:     "www.google.com",
+			Path:     "/",
+			RawQuery: "q=go%20language",
+		},
+		"",
+	},
+	// %20 outside query
+	{
+		"http://www.google.com/a%20b?q=c+d",
+		&url.URL{
+			Scheme:   "http",
+			Host:     "www.google.com",
+			Path:     "/a b",
+			RawQuery: "q=c+d",
+		},
+		"",
+	},
+	// path without leading /, so no parsing
+	{
+		"http:www.google.com/?q=go+language",
+		&url.URL{
+			Scheme:   "http",
+			Opaque:   "www.google.com/",
+			RawQuery: "q=go+language",
+		},
+		"http:www.google.com/?q=go+language",
+	},
+	// path without leading /, so no parsing
+	{
+		"http:%2f%2fwww.google.com/?q=go+language",
+		&url.URL{
+			Scheme:   "http",
+			Opaque:   "%2f%2fwww.google.com/",
+			RawQuery: "q=go+language",
+		},
+		"http:%2f%2fwww.google.com/?q=go+language",
+	},
+	// non-authority with path
+	{
+		"mailto:/webmaster@golang.org",
+		&url.URL{
+			Scheme: "mailto",
+			Path:   "/webmaster@golang.org",
+		},
+		"mailto:///webmaster@golang.org", // unfortunate compromise
+	},
+	// non-authority
+	{
+		"mailto:webmaster@golang.org",
+		&url.URL{
+			Scheme: "mailto",
+			Opaque: "webmaster@golang.org",
+		},
+		"",
+	},
+	// unescaped :// in query should not create a scheme
+	{
+		"/foo?query=http://bad",
+		&url.URL{
+			Path:     "/foo",
+			RawQuery: "query=http://bad",
+		},
+		"",
+	},
+	// leading // without scheme should create an authority
+	{
+		"//foo",
+		&url.URL{
+			Host: "foo",
+		},
+		"",
+	},
+	// leading // without scheme, with userinfo, path, and query
+	{
+		"//user@foo/path?a=b",
+		&url.URL{
+			User:     url.User("user"),
+			Host:     "foo",
+			Path:     "/path",
+			RawQuery: "a=b",
+		},
+		"",
+	},
+	// Three leading slashes isn't an authority, but doesn't return an error.
+	// (We can't return an error, as this code is also used via
+	// ServeHTTP -> ReadRequest -> Parse, which is arguably a
+	// different URL parsing context, but currently shares the
+	// same codepath)
+	{
+		"///threeslashes",
+		&url.URL{
+			Path: "///threeslashes",
+		},
+		"",
+	},
+	{
+		"http://user:password@google.com",
+		&url.URL{
+			Scheme: "http",
+			User:   url.UserPassword("user", "password"),
+			Host:   "google.com",
+		},
+		"http://user:password@google.com",
+	},
+	// unescaped @ in username should not confuse host
+	{
+		"http://j@ne:password@google.com",
+		&url.URL{
+			Scheme: "http",
+			User:   url.UserPassword("j@ne", "password"),
+			Host:   "google.com",
+		},
+		"http://j%40ne:password@google.com",
+	},
+	// unescaped @ in password should not confuse host
+	{
+		"http://jane:p@ssword@google.com",
+		&url.URL{
+			Scheme: "http",
+			User:   url.UserPassword("jane", "p@ssword"),
+			Host:   "google.com",
+		},
+		"http://jane:p%40ssword@google.com",
+	},
+	{
+		"http://j@ne:password@google.com/p@th?q=@go",
+		&url.URL{
+			Scheme:   "http",
+			User:     url.UserPassword("j@ne", "password"),
+			Host:     "google.com",
+			Path:     "/p@th",
+			RawQuery: "q=@go",
+		},
+		"http://j%40ne:password@google.com/p@th?q=@go",
+	},
+	{
+		"http://www.google.com/?q=go+language#foo",
+		&url.URL{
+			Scheme:   "http",
+			Host:     "www.google.com",
+			Path:     "/",
+			RawQuery: "q=go+language",
+			Fragment: "foo",
+		},
+		"",
+	},
+	{
+		"http://www.google.com/?q=go+language#foo%26bar",
+		&url.URL{
+			Scheme:   "http",
+			Host:     "www.google.com",
+			Path:     "/",
+			RawQuery: "q=go+language",
+			Fragment: "foo&bar",
+		},
+		"http://www.google.com/?q=go+language#foo&bar",
+	},
+	{
+		"file:///home/adg/rabbits",
+		&url.URL{
+			Scheme: "file",
+			Host:   "",
+			Path:   "/home/adg/rabbits",
+		},
+		"file:///home/adg/rabbits",
+	},
+	// "Windows" paths are no exception to the rule.
+	// See golang.org/issue/6027, especially comment #9.
+	{
+		"file:///C:/FooBar/Baz.txt",
+		&url.URL{
+			Scheme: "file",
+			Host:   "",
+			Path:   "/C:/FooBar/Baz.txt",
+		},
+		"file:///C:/FooBar/Baz.txt",
+	},
+	// case-insensitive scheme
+	{
+		"MaIlTo:webmaster@golang.org",
+		&url.URL{
+			Scheme: "mailto",
+			Opaque: "webmaster@golang.org",
+		},
+		"mailto:webmaster@golang.org",
+	},
+	// Relative path
+	{
+		"a/b/c",
+		&url.URL{
+			Path: "a/b/c",
+		},
+		"a/b/c",
+	},
+	// escaped '?' in username and password
+	{
+		"http://%3Fam:pa%3Fsword@google.com",
+		&url.URL{
+			Scheme: "http",
+			User:   url.UserPassword("?am", "pa?sword"),
+			Host:   "google.com",
+		},
+		"",
+	},
+	// escaped '?' and '#' in path
+	{
+		"http://example.com/%3F%23",
+		&url.URL{
+			Scheme: "http",
+			Host:   "example.com",
+			Path:   "?#",
+		},
+		"",
+	},
+	// unescaped [ ] ! ' ( ) * in path
+	{
+		"http://example.com/[]!'()*",
+		&url.URL{
+			Scheme: "http",
+			Host:   "example.com",
+			Path:   "[]!'()*",
+		},
+		"http://example.com/[]!'()*",
+	},
+	// escaped : / ? # [ ] @ in username and password
+	{
+		"http://%3A%2F%3F:%23%5B%5D%40@example.com",
+		&url.URL{
+			Scheme: "http",
+			User:   url.UserPassword(":/?", "#[]@"),
+			Host:   "example.com",
+		},
+		"",
+	},
+	// unescaped ! $ & ' ( ) * + , ; = in username and password
+	{
+		"http://!$&'():*+,;=@example.com",
+		&url.URL{
+			Scheme: "http",
+			User:   url.UserPassword("!$&'()", "*+,;="),
+			Host:   "example.com",
+		},
+		"",
+	},
+	// unescaped = : / . ? = in query component
+	{
+		"http://example.com/?q=http://google.com/?q=",
+		&url.URL{
+			Scheme:   "http",
+			Host:     "example.com",
+			Path:     "/",
+			RawQuery: "q=http://google.com/?q=",
+		},
+		"",
+	},
+	// unescaped : / ? [ ] @ ! $ & ' ( ) * + , ; = in fragment
+	{
+		"http://example.com/#:/?%23[]@!$&'()*+,;=",
+		&url.URL{
+			Scheme:   "http",
+			Host:     "example.com",
+			Path:     "/",
+			Fragment: ":/?#[]@!$&'()*+,;=",
+		},
+		"",
+	},
+}
+
+func DoTestString(t *testing.T, parse func(string) (*url.URL, error), name string, tests []URLTest) {
+	for _, tt := range tests {
+		u, err := parse(tt.in)
+		if err != nil {
+			t.Errorf("%s(%q) returned error %s", name, tt.in, err)
+			continue
+		}
+		expected := tt.in
+		if len(tt.roundtrip) > 0 {
+			expected = tt.roundtrip
+		}
+		s := Escape(u)
+		if s != expected {
+			t.Errorf("Escape(%s(%q)) == %q (expected %q)", name, tt.in, s, expected)
+		}
+	}
+}
+
+func TestURLString(t *testing.T) {
+	DoTestString(t, url.Parse, "Parse", urltests)
+
+	// no leading slash on path should prepend
+	// slash on String() call
+	noslash := URLTest{
+		"http://www.google.com/search",
+		&url.URL{
+			Scheme: "http",
+			Host:   "www.google.com",
+			Path:   "search",
+		},
+		"",
+	}
+	s := Escape(noslash.out)
+	if s != noslash.in {
+		t.Errorf("Expected %s; go %s", noslash.in, s)
+	}
+}
+
+type EscapeTest struct {
+	in  string
+	out string
+	err error
+}
+
+var escapeTests = []EscapeTest{
+	{
+		"",
+		"",
+		nil,
+	},
+	{
+		"abc",
+		"abc",
+		nil,
+	},
+	{
+		"one two",
+		"one+two",
+		nil,
+	},
+	{
+		"10%",
+		"10%25",
+		nil,
+	},
+	{
+		" ?&=#+%!<>#\"{}|\\^[]`☺\t:/@$'()*,;",
+		"+?%26%3D%23%2B%25%21%3C%3E%23%22%7B%7D%7C%5C%5E%5B%5D%60%E2%98%BA%09%3A/%40%24%27%28%29%2A%2C%3B",
+		nil,
+	},
+}
+
+func TestEscape(t *testing.T) {
+	for _, tt := range escapeTests {
+		actual := QueryEscape(tt.in)
+		if tt.out != actual {
+			t.Errorf("QueryEscape(%q) = %q, want %q", tt.in, actual, tt.out)
+		}
+
+		// for bonus points, verify that escape:unescape is an identity.
+		roundtrip, err := url.QueryUnescape(actual)
+		if roundtrip != tt.in || err != nil {
+			t.Errorf("QueryUnescape(%q) = %q, %s; want %q, %s", actual, roundtrip, err, tt.in, "[no error]")
+		}
+	}
+}
+
+var resolveReferenceTests = []struct {
+	base, rel, expected string
+}{
+	// Absolute URL references
+	{"http://foo.com?a=b", "https://bar.com/", "https://bar.com/"},
+	{"http://foo.com/", "https://bar.com/?a=b", "https://bar.com/?a=b"},
+	{"http://foo.com/bar", "mailto:foo@example.com", "mailto:foo@example.com"},
+
+	// Path-absolute references
+	{"http://foo.com/bar", "/baz", "http://foo.com/baz"},
+	{"http://foo.com/bar?a=b#f", "/baz", "http://foo.com/baz"},
+	{"http://foo.com/bar?a=b", "/baz?c=d", "http://foo.com/baz?c=d"},
+
+	// Scheme-relative
+	{"https://foo.com/bar?a=b", "//bar.com/quux", "https://bar.com/quux"},
+
+	// Path-relative references:
+
+	// ... current directory
+	{"http://foo.com", ".", "http://foo.com/"},
+	{"http://foo.com/bar", ".", "http://foo.com/"},
+	{"http://foo.com/bar/", ".", "http://foo.com/bar/"},
+
+	// ... going down
+	{"http://foo.com", "bar", "http://foo.com/bar"},
+	{"http://foo.com/", "bar", "http://foo.com/bar"},
+	{"http://foo.com/bar/baz", "quux", "http://foo.com/bar/quux"},
+
+	// ... going up
+	{"http://foo.com/bar/baz", "../quux", "http://foo.com/quux"},
+	{"http://foo.com/bar/baz", "../../../../../quux", "http://foo.com/quux"},
+	{"http://foo.com/bar", "..", "http://foo.com/"},
+	{"http://foo.com/bar/baz", "./..", "http://foo.com/"},
+	// ".." in the middle (issue 3560)
+	{"http://foo.com/bar/baz", "quux/dotdot/../tail", "http://foo.com/bar/quux/tail"},
+	{"http://foo.com/bar/baz", "quux/./dotdot/../tail", "http://foo.com/bar/quux/tail"},
+	{"http://foo.com/bar/baz", "quux/./dotdot/.././tail", "http://foo.com/bar/quux/tail"},
+	{"http://foo.com/bar/baz", "quux/./dotdot/./../tail", "http://foo.com/bar/quux/tail"},
+	{"http://foo.com/bar/baz", "quux/./dotdot/dotdot/././../../tail", "http://foo.com/bar/quux/tail"},
+	{"http://foo.com/bar/baz", "quux/./dotdot/dotdot/./.././../tail", "http://foo.com/bar/quux/tail"},
+	{"http://foo.com/bar/baz", "quux/./dotdot/dotdot/dotdot/./../../.././././tail", "http://foo.com/bar/quux/tail"},
+	{"http://foo.com/bar/baz", "quux/./dotdot/../dotdot/../dot/./tail/..", "http://foo.com/bar/quux/dot/"},
+
+	// Remove any dot-segments prior to forming the target URI.
+	// http://tools.ietf.org/html/rfc3986#section-5.2.4
+	{"http://foo.com/dot/./dotdot/../foo/bar", "../baz", "http://foo.com/dot/baz"},
+
+	// Triple dot isn't special
+	{"http://foo.com/bar", "...", "http://foo.com/..."},
+
+	// Fragment
+	{"http://foo.com/bar", ".#frag", "http://foo.com/#frag"},
+
+	// RFC 3986: Normal Examples
+	// http://tools.ietf.org/html/rfc3986#section-5.4.1
+	{"http://a/b/c/d;p?q", "g:h", "g:h"},
+	{"http://a/b/c/d;p?q", "g", "http://a/b/c/g"},
+	{"http://a/b/c/d;p?q", "./g", "http://a/b/c/g"},
+	{"http://a/b/c/d;p?q", "g/", "http://a/b/c/g/"},
+	{"http://a/b/c/d;p?q", "/g", "http://a/g"},
+	{"http://a/b/c/d;p?q", "//g", "http://g"},
+	{"http://a/b/c/d;p?q", "?y", "http://a/b/c/d;p?y"},
+	{"http://a/b/c/d;p?q", "g?y", "http://a/b/c/g?y"},
+	{"http://a/b/c/d;p?q", "#s", "http://a/b/c/d;p?q#s"},
+	{"http://a/b/c/d;p?q", "g#s", "http://a/b/c/g#s"},
+	{"http://a/b/c/d;p?q", "g?y#s", "http://a/b/c/g?y#s"},
+	{"http://a/b/c/d;p?q", ";x", "http://a/b/c/;x"},
+	{"http://a/b/c/d;p?q", "g;x", "http://a/b/c/g;x"},
+	{"http://a/b/c/d;p?q", "g;x?y#s", "http://a/b/c/g;x?y#s"},
+	{"http://a/b/c/d;p?q", "", "http://a/b/c/d;p?q"},
+	{"http://a/b/c/d;p?q", ".", "http://a/b/c/"},
+	{"http://a/b/c/d;p?q", "./", "http://a/b/c/"},
+	{"http://a/b/c/d;p?q", "..", "http://a/b/"},
+	{"http://a/b/c/d;p?q", "../", "http://a/b/"},
+	{"http://a/b/c/d;p?q", "../g", "http://a/b/g"},
+	{"http://a/b/c/d;p?q", "../..", "http://a/"},
+	{"http://a/b/c/d;p?q", "../../", "http://a/"},
+	{"http://a/b/c/d;p?q", "../../g", "http://a/g"},
+
+	// RFC 3986: Abnormal Examples
+	// http://tools.ietf.org/html/rfc3986#section-5.4.2
+	{"http://a/b/c/d;p?q", "../../../g", "http://a/g"},
+	{"http://a/b/c/d;p?q", "../../../../g", "http://a/g"},
+	{"http://a/b/c/d;p?q", "/./g", "http://a/g"},
+	{"http://a/b/c/d;p?q", "/../g", "http://a/g"},
+	{"http://a/b/c/d;p?q", "g.", "http://a/b/c/g."},
+	{"http://a/b/c/d;p?q", ".g", "http://a/b/c/.g"},
+	{"http://a/b/c/d;p?q", "g..", "http://a/b/c/g.."},
+	{"http://a/b/c/d;p?q", "..g", "http://a/b/c/..g"},
+	{"http://a/b/c/d;p?q", "./../g", "http://a/b/g"},
+	{"http://a/b/c/d;p?q", "./g/.", "http://a/b/c/g/"},
+	{"http://a/b/c/d;p?q", "g/./h", "http://a/b/c/g/h"},
+	{"http://a/b/c/d;p?q", "g/../h", "http://a/b/c/h"},
+	{"http://a/b/c/d;p?q", "g;x=1/./y", "http://a/b/c/g;x=1/y"},
+	{"http://a/b/c/d;p?q", "g;x=1/../y", "http://a/b/c/y"},
+	{"http://a/b/c/d;p?q", "g?y/./x", "http://a/b/c/g?y/./x"},
+	{"http://a/b/c/d;p?q", "g?y/../x", "http://a/b/c/g?y/../x"},
+	{"http://a/b/c/d;p?q", "g#s/./x", "http://a/b/c/g#s/./x"},
+	{"http://a/b/c/d;p?q", "g#s/../x", "http://a/b/c/g#s/../x"},
+
+	// Extras.
+	{"https://a/b/c/d;p?q", "//g?q", "https://g?q"},
+	{"https://a/b/c/d;p?q", "//g#s", "https://g#s"},
+	{"https://a/b/c/d;p?q", "//g/d/e/f?y#s", "https://g/d/e/f?y#s"},
+	{"https://a/b/c/d;p#s", "?y", "https://a/b/c/d;p?y"},
+	{"https://a/b/c/d;p?q#s", "?y", "https://a/b/c/d;p?y"},
+}
+
+func TestResolveReference(t *testing.T) {
+	mustParse := func(url_ string) *url.URL {
+		u, err := url.Parse(url_)
+		if err != nil {
+			t.Fatalf("Expected URL to parse: %q, got error: %v", url_, err)
+		}
+		return u
+	}
+	opaque := &url.URL{Scheme: "scheme", Opaque: "opaque"}
+	for _, test := range resolveReferenceTests {
+		base := mustParse(test.base)
+		rel := mustParse(test.rel)
+		url := base.ResolveReference(rel)
+		if Escape(url) != test.expected {
+			t.Errorf("URL(%q).ResolveReference(%q) == %q, got %q", test.base, test.rel, test.expected, Escape(url))
+		}
+		// Ensure that new instances are returned.
+		if base == url {
+			t.Errorf("Expected URL.ResolveReference to return new URL instance.")
+		}
+		// Test the convenience wrapper too.
+		url, err := base.Parse(test.rel)
+		if err != nil {
+			t.Errorf("URL(%q).Parse(%q) failed: %v", test.base, test.rel, err)
+		} else if Escape(url) != test.expected {
+			t.Errorf("URL(%q).Parse(%q) == %q, got %q", test.base, test.rel, test.expected, Escape(url))
+		} else if base == url {
+			// Ensure that new instances are returned for the wrapper too.
+			t.Errorf("Expected URL.Parse to return new URL instance.")
+		}
+		// Ensure Opaque resets the URL.
+		url = base.ResolveReference(opaque)
+		if *url != *opaque {
+			t.Errorf("ResolveReference failed to resolve opaque URL: want %#v, got %#v", url, opaque)
+		}
+		// Test the convenience wrapper with an opaque URL too.
+		url, err = base.Parse("scheme:opaque")
+		if err != nil {
+			t.Errorf(`URL(%q).Parse("scheme:opaque") failed: %v`, test.base, err)
+		} else if *url != *opaque {
+			t.Errorf("Parse failed to resolve opaque URL: want %#v, got %#v", url, opaque)
+		} else if base == url {
+			// Ensure that new instances are returned, again.
+			t.Errorf("Expected URL.Parse to return new URL instance.")
+		}
+	}
+}
+
+type shouldEscapeTest struct {
+	in     byte
+	mode   encoding
+	escape bool
+}
+
+var shouldEscapeTests = []shouldEscapeTest{
+	// Unreserved characters (§2.3)
+	{'a', encodePath, false},
+	{'a', encodeUserPassword, false},
+	{'a', encodeQueryComponent, false},
+	{'a', encodeFragment, false},
+	{'z', encodePath, false},
+	{'A', encodePath, false},
+	{'Z', encodePath, false},
+	{'0', encodePath, false},
+	{'9', encodePath, false},
+	{'-', encodePath, false},
+	{'-', encodeUserPassword, false},
+	{'-', encodeQueryComponent, false},
+	{'-', encodeFragment, false},
+	{'.', encodePath, false},
+	{'_', encodePath, false},
+	{'~', encodePath, false},
+
+	// User information (§3.2.1)
+	{':', encodeUserPassword, true},
+	{'/', encodeUserPassword, true},
+	{'?', encodeUserPassword, true},
+	{'@', encodeUserPassword, true},
+	{'$', encodeUserPassword, false},
+	{'&', encodeUserPassword, false},
+	{'+', encodeUserPassword, false},
+	{',', encodeUserPassword, false},
+	{';', encodeUserPassword, false},
+	{'=', encodeUserPassword, false},
+}
+
+func TestShouldEscape(t *testing.T) {
+	for _, tt := range shouldEscapeTests {
+		if shouldEscape(tt.in, tt.mode) != tt.escape {
+			t.Errorf("shouldEscape(%q, %v) returned %v; expected %v", tt.in, tt.mode, !tt.escape, tt.escape)
+		}
+	}
+}
--- a/vendor/github.com/container-storage-interface/spec/.gitignore
+++ b/vendor/github.com/container-storage-interface/spec/.gitignore
@ -0,0 +1,2 @@
+/csi.proto.tmp
+.DS_Store
--- a/vendor/github.com/container-storage-interface/spec/.travis.yml
+++ b/vendor/github.com/container-storage-interface/spec/.travis.yml
@ -0,0 +1,38 @@
+# Setting "sudo" to false forces Travis-CI to use its
+# container-based build infrastructure, which has shorter
+# queue times.
+sudo: false
+
+# Use the newer Travis-CI build templates based on the
+# Debian Linux distribution "Trusty" release.
+dist: trusty
+
+# Selecting C as the language keeps the container to a
+# minimum footprint.
+language: c
+
+jobs:
+  include:
+
+    # The test stage validates that the protobuf file was updated
+    # correctly prior to being committed.
+    - stage:               test
+      script:              make
+
+    # The lang stages validate the specification using
+    # language-specific bindings.
+
+    # Lang stage: Cxx
+    - stage:               lang
+      script:              make -C lib/cxx
+
+    # Lang stage: Go
+    - stage:               lang
+      language:            go
+      go:                  1.8.3
+      go_import_path:      github.com/container-storage-interface/spec
+      install:
+        - make -C lib/go protoc
+        - make -C lib/go protoc-gen-go
+      script:
+        - make -C lib/go
--- a/vendor/github.com/container-storage-interface/spec/CONTRIBUTING.md
+++ b/vendor/github.com/container-storage-interface/spec/CONTRIBUTING.md
@ -0,0 +1,48 @@
+# How to Contribute
+
+CSI is under [Apache 2.0](LICENSE) and accepts contributions via GitHub pull requests.
+This document outlines some of the conventions on development workflow, commit message formatting, contact points and other resources to make it easier to get your contribution accepted.
+
+## Markdown style
+
+To keep consistency throughout the Markdown files in the CSI spec, all files should be formatted one sentence per line.
+This fixes two things: it makes diffing easier with git and it resolves fights about line wrapping length.
+For example, this paragraph will span three lines in the Markdown source.
+
+## Code style
+
+This also applies to the code snippets in the markdown files.
+
+* Please wrap the code at 72 characters.
+
+## Comments
+
+This also applies to the code snippets in the markdown files.
+
+* End each sentence within a comment with a punctuation mark (please note that we generally prefer periods); this applies to incomplete sentences as well.
+* For trailing comments, leave one space between the end of the code and the beginning of the comment.
+
+## Git commit
+
+Prior to committing code please run `make` in order to update the protobuf file and any language bindings.
+
+### Commit Style
+
+Each commit should represent a single logical (atomic) change: this makes your changes easier to review.
+
+* Try to avoid unrelated cleanups (e.g., typo fixes or style nits) in the same commit that makes functional changes.
+  While typo fixes are great, including them in the same commit as functional changes makes the commit history harder to read.
+* Developers often make incremental commits to save their progress when working on a change, and then “rewrite history” (e.g., using `git rebase -i`) to create a clean set of commits once the change is ready to be reviewed.
+
+Simple house-keeping for clean git history.
+Read more on [How to Write a Git Commit Message](http://chris.beams.io/posts/git-commit/) or the Discussion section of [`git-commit(1)`](http://git-scm.com/docs/git-commit).
+
+* Separate the subject from body with a blank line.
+* Limit the subject line to 50 characters.
+* Capitalize the subject line.
+* Do not end the subject line with a period.
+* Use the imperative mood in the subject line.
+* Wrap the body at 72 characters.
+* Use the body to explain what and why vs. how.
+  * If there was important/useful/essential conversation or information, copy or include a reference.
+* When possible, one keyword to scope the change in the subject (i.e. "README: ...", "tool: ...").
--- a/vendor/github.com/container-storage-interface/spec/LICENSE
+++ b/vendor/github.com/container-storage-interface/spec/LICENSE
@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/vendor/github.com/container-storage-interface/spec/Makefile
+++ b/vendor/github.com/container-storage-interface/spec/Makefile
@ -0,0 +1,50 @@
+all: build
+
+CSI_SPEC := spec.md
+CSI_PROTO := csi.proto
+
+# This is the target for building the temporary CSI protobuf file.
+#
+# The temporary file is not versioned, and thus will always be
+# built on Travis-CI.
+$(CSI_PROTO).tmp: $(CSI_SPEC)
+	cat $? | \
+	  sed -n -e '/```protobuf$$/,/```$$/ p' | \
+	  sed -e 's@^```.*$$@////////@g' > $@
+
+# This is the target for building the CSI protobuf file.
+#
+# This target depends on its temp file, which is not versioned.
+# Therefore when built on Travis-CI the temp file will always
+# be built and trigger this target. On Travis-CI the temp file
+# is compared with the real file, and if they differ the build
+# will fail.
+#
+# Locally the temp file is simply copied over the real file.
+$(CSI_PROTO): $(CSI_PROTO).tmp
+ifeq (true,$(TRAVIS))
+	diff "$@" "$?"
+else
+	diff "$@" "$?" > /dev/null 2>&1 || cp -f "$?" "$@"
+endif
+
+build: check
+
+# If this is not running on Travis-CI then for sake of convenience
+# go ahead and update the language bindings as well.
+ifneq (true,$(TRAVIS))
+build:
+	$(MAKE) -C lib/go
+	$(MAKE) -C lib/cxx
+endif
+
+clean:
+
+clobber: clean
+	rm -f $(CSI_PROTO) $(CSI_PROTO).tmp
+
+# check generated files for violation of standards
+check: $(CSI_PROTO)
+	awk '{ if (length > 72) print NR, $$0 }' $? | diff - /dev/null
+
+.PHONY: clean clobber check
--- a/vendor/github.com/container-storage-interface/spec/OWNERS
+++ b/vendor/github.com/container-storage-interface/spec/OWNERS
@ -0,0 +1,10 @@
+approvers:
+  - saad-ali # Representing Kubernetes
+  - thockin # Representing Kubernetes
+  - jieyu # Representing Mesos
+  - jdef # Representing Mesos
+  - cpuguy83 # Representing Docker
+  - mycure # Representing Docker
+  - julian-hj # Representing Cloud Foundry 
+  - paulcwarren # Representing Cloud Foundry 
+reviewers:
--- a/vendor/github.com/container-storage-interface/spec/README.md
+++ b/vendor/github.com/container-storage-interface/spec/README.md
@ -0,0 +1,5 @@
+# Container Storage Interface (CSI) Specification [![build status](https://travis-ci.org/container-storage-interface/spec.svg?branch=master)](https://travis-ci.org/container-storage-interface/spec)
+
+![CSI Logo](logo.png)
+
+This project contains the CSI [specification](spec.md) and [protobuf](csi.proto) files.
--- a/vendor/github.com/container-storage-interface/spec/VERSION
+++ b/vendor/github.com/container-storage-interface/spec/VERSION
@ -0,0 +1 @@
+0.2.0
--- a/vendor/github.com/container-storage-interface/spec/csi.proto
+++ b/vendor/github.com/container-storage-interface/spec/csi.proto
@ -0,0 +1,627 @@
+////////
+syntax = "proto3";
+package csi;
+////////
+////////
+service Identity {
+  rpc GetSupportedVersions (GetSupportedVersionsRequest)
+    returns (GetSupportedVersionsResponse) {}
+
+  rpc GetPluginInfo(GetPluginInfoRequest)
+    returns (GetPluginInfoResponse) {}
+}
+
+service Controller {
+  rpc CreateVolume (CreateVolumeRequest)
+    returns (CreateVolumeResponse) {}
+
+  rpc DeleteVolume (DeleteVolumeRequest)
+    returns (DeleteVolumeResponse) {}
+
+  rpc ControllerPublishVolume (ControllerPublishVolumeRequest)
+    returns (ControllerPublishVolumeResponse) {}
+
+  rpc ControllerUnpublishVolume (ControllerUnpublishVolumeRequest)
+    returns (ControllerUnpublishVolumeResponse) {}
+
+  rpc ValidateVolumeCapabilities (ValidateVolumeCapabilitiesRequest)
+    returns (ValidateVolumeCapabilitiesResponse) {}
+
+  rpc ListVolumes (ListVolumesRequest)
+    returns (ListVolumesResponse) {}
+
+  rpc GetCapacity (GetCapacityRequest)
+    returns (GetCapacityResponse) {}
+
+  rpc ControllerProbe (ControllerProbeRequest)
+    returns (ControllerProbeResponse) {}
+
+  rpc ControllerGetCapabilities (ControllerGetCapabilitiesRequest)
+    returns (ControllerGetCapabilitiesResponse) {}  
+}
+
+service Node {
+  rpc NodePublishVolume (NodePublishVolumeRequest)
+    returns (NodePublishVolumeResponse) {}
+
+  rpc NodeUnpublishVolume (NodeUnpublishVolumeRequest)
+    returns (NodeUnpublishVolumeResponse) {}
+
+  rpc GetNodeID (GetNodeIDRequest)
+    returns (GetNodeIDResponse) {}
+
+  rpc NodeProbe (NodeProbeRequest)
+    returns (NodeProbeResponse) {}
+
+  rpc NodeGetCapabilities (NodeGetCapabilitiesRequest)
+    returns (NodeGetCapabilitiesResponse) {}
+}
+////////
+////////
+message GetSupportedVersionsRequest {
+}
+
+message GetSupportedVersionsResponse {
+  // All the CSI versions that the Plugin supports. This field is
+  // REQUIRED.
+  repeated Version supported_versions = 1;
+}
+
+// Specifies a version in Semantic Version 2.0 format.
+// (http://semver.org/spec/v2.0.0.html)
+message Version {
+  uint32 major = 1;  // This field is REQUIRED.
+  uint32 minor = 2;  // This field is REQUIRED.
+  uint32 patch = 3;  // This field is REQUIRED.
+}
+////////
+////////
+message GetPluginInfoRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+}
+
+message GetPluginInfoResponse {
+  // The name MUST follow reverse domain name notation format
+  // (https://en.wikipedia.org/wiki/Reverse_domain_name_notation).
+  // It SHOULD include the plugin's host company name and the plugin
+  // name, to minimize the possibility of collisions. It MUST be 63
+  // characters or less, beginning and ending with an alphanumeric
+  // character ([a-z0-9A-Z]) with dashes (-), underscores (_),
+  // dots (.), and alphanumerics between. This field is REQUIRED.
+  string name = 1;
+
+  // This field is REQUIRED. Value of this field is opaque to the CO.
+  string vendor_version = 2;
+
+  // This field is OPTIONAL. Values are opaque to the CO.
+  map<string, string> manifest = 3;
+}
+////////
+////////
+message CreateVolumeRequest {
+  // The API version assumed by the CO. This field is REQUIRED.
+  Version version = 1;
+
+  // The suggested name for the storage space. This field is REQUIRED.
+  // It serves two purposes:
+  // 1) Idempotency - This name is generated by the CO to achieve
+  //    idempotency. If `CreateVolume` fails, the volume may or may not
+  //    be provisioned. In this case, the CO may call `CreateVolume`
+  //    again, with the same name, to ensure the volume exists. The
+  //    Plugin should ensure that multiple `CreateVolume` calls for the
+  //    same name do not result in more than one piece of storage
+  //    provisioned corresponding to that name. If a Plugin is unable to
+  //    enforce idempotency, the CO's error recovery logic could result
+  //    in multiple (unused) volumes being provisioned.
+  // 2) Suggested name - Some storage systems allow callers to specify
+  //    an identifier by which to refer to the newly provisioned
+  //    storage. If a storage system supports this, it can optionally
+  //    use this name as the identifier for the new volume.
+  string name = 2;
+
+  // This field is OPTIONAL. This allows the CO to specify the capacity
+  // requirement of the volume to be provisioned. If not specified, the
+  // Plugin MAY choose an implementation-defined capacity range.
+  CapacityRange capacity_range = 3;
+
+  // The capabilities that the provisioned volume MUST have: the Plugin
+  // MUST provision a volume that could satisfy ALL of the
+  // capabilities specified in this list. The Plugin MUST assume that
+  // the CO MAY use the  provisioned volume later with ANY of the
+  // capabilities specified in this list. This also enables the CO to do
+  // early validation: if ANY of the specified volume capabilities are
+  // not supported by the Plugin, the call SHALL fail. This field is
+  // REQUIRED.
+  repeated VolumeCapability volume_capabilities = 4;
+
+  // Plugin specific parameters passed in as opaque key-value pairs.
+  // This field is OPTIONAL. The Plugin is responsible for parsing and
+  // validating these parameters. COs will treat these as opaque.
+  map<string, string> parameters = 5;
+
+  // End user credentials used to authenticate/authorize volume creation
+  // request.
+  // This field contains credential data, for example username and
+  // password. Each key must consist of alphanumeric characters, '-',
+  // '_' or '.'. Each value MUST contain a valid string. An SP MAY
+  // choose to accept binary (non-string) data by using a binary-to-text
+  // encoding scheme, like base64. An SP SHALL advertise the
+  // requirements for credentials in documentation. COs SHALL permit
+  // users to pass through the required credentials. This information is
+  // sensitive and MUST be treated as such (not logged, etc.) by the CO.
+  // This field is OPTIONAL.
+  map<string, string> user_credentials = 6;
+}
+
+message CreateVolumeResponse {
+  // Contains all attributes of the newly created volume that are
+  // relevant to the CO along with information required by the Plugin
+  // to uniquely identify the volume. This field is REQUIRED.
+  VolumeInfo volume_info = 1;
+}
+
+// Specify a capability of a volume.
+message VolumeCapability {
+  // Indicate that the volume will be accessed via the block device API.
+  message BlockVolume {
+    // Intentionally empty, for now.
+  }
+
+  // Indicate that the volume will be accessed via the filesystem API.
+  message MountVolume {
+    // The filesystem type. This field is OPTIONAL.
+    // An empty string is equal to an unspecified field value.
+    string fs_type = 1;
+
+    // The mount options that can be used for the volume. This field is
+    // OPTIONAL. `mount_flags` MAY contain sensitive information.
+    // Therefore, the CO and the Plugin MUST NOT leak this information
+    // to untrusted entities. The total size of this repeated field
+    // SHALL NOT exceed 4 KiB.
+    repeated string mount_flags = 2;    
+  }
+
+  // Specify how a volume can be accessed.
+  message AccessMode {
+    enum Mode {
+      UNKNOWN = 0;
+
+      // Can only be published once as read/write on a single node, at
+      // any given time.
+      SINGLE_NODE_WRITER = 1;
+
+      // Can only be published once as readonly on a single node, at
+      // any given time.
+      SINGLE_NODE_READER_ONLY = 2;
+
+      // Can be published as readonly at multiple nodes simultaneously.
+      MULTI_NODE_READER_ONLY = 3;
+
+      // Can be published at multiple nodes simultaneously. Only one of
+      // the node can be used as read/write. The rest will be readonly.
+      MULTI_NODE_SINGLE_WRITER = 4;
+
+      // Can be published as read/write at multiple nodes
+      // simultaneously.
+      MULTI_NODE_MULTI_WRITER = 5;
+    }
+
+    // This field is REQUIRED.
+    Mode mode = 1;
+  }
+
+  // Specifies what API the volume will be accessed using. One of the
+  // following fields MUST be specified.
+  oneof access_type {
+    BlockVolume block = 1;
+    MountVolume mount = 2;
+  }
+
+  // This is a REQUIRED field.
+  AccessMode access_mode = 3;
+}
+
+// The capacity of the storage space in bytes. To specify an exact size,
+// `required_bytes` and `limit_bytes` can be set to the same value. At
+// least one of the these fields MUST be specified.
+message CapacityRange {
+  // Volume must be at least this big. This field is OPTIONAL.
+  // A value of 0 is equal to an unspecified field value.
+  uint64 required_bytes = 1;
+
+  // Volume must not be bigger than this. This field is OPTIONAL.
+  // A value of 0 is equal to an unspecified field value.
+  uint64 limit_bytes = 2;
+}
+
+// The information about a provisioned volume.
+message VolumeInfo {
+  // The capacity of the volume in bytes. This field is OPTIONAL. If not
+  // set (value of 0), it indicates that the capacity of the volume is
+  // unknown (e.g., NFS share).
+  uint64 capacity_bytes = 1;
+
+  // Contains identity information for the created volume. This field is
+  // REQUIRED. The identity information will be used by the CO in
+  // subsequent calls to refer to the provisioned volume.
+  string id = 2;
+
+  // Attributes reflect static properties of a volume and MUST be passed
+  // to volume validation and publishing calls.
+  // Attributes SHALL be opaque to a CO. Attributes SHALL NOT be mutable
+  // and SHALL be safe for the CO to cache. Attributes SHOULD NOT
+  // contain sensitive information. Attributes MAY NOT uniquely identify
+  // a volume. A volume uniquely identified by `id` SHALL always report
+  // the same attributes. This field is OPTIONAL and when present MUST
+  // be passed to volume validation and publishing calls.
+  map<string,string> attributes = 3;
+}
+////////
+////////
+message DeleteVolumeRequest {
+  // The API version assumed by the CO. This field is REQUIRED.
+  Version version = 1;
+
+  // The ID of the volume to be deprovisioned.
+  // This field is REQUIRED.
+  string volume_id = 2;
+
+  // End user credentials used to authenticate/authorize volume deletion
+  // request.
+  // This field contains credential data, for example username and
+  // password. Each key must consist of alphanumeric characters, '-',
+  // '_' or '.'. Each value MUST contain a valid string. An SP MAY
+  // choose to accept binary (non-string) data by using a binary-to-text
+  // encoding scheme, like base64. An SP SHALL advertise the
+  // requirements for credentials in documentation. COs SHALL permit
+  // users to pass through the required credentials. This information is
+  // sensitive and MUST be treated as such (not logged, etc.) by the CO.
+  // This field is OPTIONAL.
+  map<string, string> user_credentials = 3;
+}
+
+message DeleteVolumeResponse {}
+////////
+////////
+message ControllerPublishVolumeRequest {
+  // The API version assumed by the CO. This field is REQUIRED.
+  Version version = 1;
+
+  // The ID of the volume to be used on a node.
+  // This field is REQUIRED.
+  string volume_id = 2;
+
+  // The ID of the node. This field is REQUIRED. The CO SHALL set this
+  // field to match the node ID returned by `GetNodeID`.
+  string node_id = 3;
+
+  // The capability of the volume the CO expects the volume to have.
+  // This is a REQUIRED field.
+  VolumeCapability volume_capability = 4;
+
+  // Whether to publish the volume in readonly mode. This field is
+  // REQUIRED.
+  bool readonly = 5;
+
+  // End user credentials used to authenticate/authorize controller
+  // publish request.
+  // This field contains credential data, for example username and
+  // password. Each key must consist of alphanumeric characters, '-',
+  // '_' or '.'. Each value MUST contain a valid string. An SP MAY
+  // choose to accept binary (non-string) data by using a binary-to-text
+  // encoding scheme, like base64. An SP SHALL advertise the
+  // requirements for credentials in documentation. COs SHALL permit
+  // users to pass through the required credentials. This information is
+  // sensitive and MUST be treated as such (not logged, etc.) by the CO.
+  // This field is OPTIONAL.
+  map<string, string> user_credentials = 6;
+
+  // Attributes of the volume to be used on a node. This field is
+  // OPTIONAL and MUST match the attributes of the VolumeInfo identified
+  // by `volume_id`.
+  map<string,string> volume_attributes = 7;
+}
+
+message ControllerPublishVolumeResponse {
+  // The SP specific information that will be passed to the Plugin in
+  // the subsequent `NodePublishVolume` call for the given volume.
+  // This information is opaque to the CO. This field is OPTIONAL.
+  map<string, string> publish_volume_info = 1;
+}
+////////
+////////
+message ControllerUnpublishVolumeRequest {
+  // The API version assumed by the CO. This field is REQUIRED.
+  Version version = 1;
+
+  // The ID of the volume. This field is REQUIRED.
+  string volume_id = 2;
+
+  // The ID of the node. This field is OPTIONAL. The CO SHOULD set this
+  // field to match the node ID returned by `GetNodeID` or leave it
+  // unset. If the value is set, the SP MUST unpublish the volume from
+  // the specified node. If the value is unset, the SP MUST unpublish
+  // the volume from all nodes it is published to.
+  string node_id = 3;
+
+  // End user credentials used to authenticate/authorize controller
+  // unpublish request.
+  // This field contains credential data, for example username and
+  // password. Each key must consist of alphanumeric characters, '-',
+  // '_' or '.'. Each value MUST contain a valid string. An SP MAY
+  // choose to accept binary (non-string) data by using a binary-to-text
+  // encoding scheme, like base64. An SP SHALL advertise the
+  // requirements for credentials in documentation. COs SHALL permit
+  // users to pass through the required credentials. This information is
+  // sensitive and MUST be treated as such (not logged, etc.) by the CO.
+  // This field is OPTIONAL.
+  map<string, string> user_credentials = 4;
+}
+
+message ControllerUnpublishVolumeResponse {}
+////////
+////////
+message ValidateVolumeCapabilitiesRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+
+  // The ID of the volume to check. This field is REQUIRED.
+  string volume_id = 2;
+
+  // The capabilities that the CO wants to check for the volume. This
+  // call SHALL return "supported" only if all the volume capabilities
+  // specified below are supported. This field is REQUIRED.
+  repeated VolumeCapability volume_capabilities = 3;
+
+  // Attributes of the volume to check. This field is OPTIONAL and MUST
+  // match the attributes of the VolumeInfo identified by `volume_id`.
+  map<string,string> volume_attributes = 4;
+}
+
+message ValidateVolumeCapabilitiesResponse {
+  // True if the Plugin supports the specified capabilities for the
+  // given volume. This field is REQUIRED.
+  bool supported = 1;
+
+  // Message to the CO if `supported` above is false. This field is
+  // OPTIONAL.
+  // An empty string is equal to an unspecified field value.
+  string message = 2;
+}
+////////
+////////
+message ListVolumesRequest {
+  // The API version assumed by the CO. This field is REQUIRED.
+  Version version = 1;
+
+  // If specified (non-zero value), the Plugin MUST NOT return more
+  // entries than this number in the response. If the actual number of
+  // entries is more than this number, the Plugin MUST set `next_token`
+  // in the response which can be used to get the next page of entries
+  // in the subsequent `ListVolumes` call. This field is OPTIONAL. If
+  // not specified (zero value), it means there is no restriction on the
+  // number of entries that can be returned.
+  uint32 max_entries = 2;
+
+  // A token to specify where to start paginating. Set this field to
+  // `next_token` returned by a previous `ListVolumes` call to get the
+  // next page of entries. This field is OPTIONAL.
+  // An empty string is equal to an unspecified field value.
+  string starting_token = 3;
+}
+
+message ListVolumesResponse {
+  message Entry {
+    VolumeInfo volume_info = 1;
+  }
+
+  repeated Entry entries = 1;
+
+  // This token allows you to get the next page of entries for
+  // `ListVolumes` request. If the number of entries is larger than
+  // `max_entries`, use the `next_token` as a value for the
+  // `starting_token` field in the next `ListVolumes` request. This
+  // field is OPTIONAL.
+  // An empty string is equal to an unspecified field value.
+  string next_token = 2;
+}
+////////
+////////
+message GetCapacityRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+
+  // If specified, the Plugin SHALL report the capacity of the storage
+  // that can be used to provision volumes that satisfy ALL of the
+  // specified `volume_capabilities`. These are the same
+  // `volume_capabilities` the CO will use in `CreateVolumeRequest`.
+  // This field is OPTIONAL.
+  repeated VolumeCapability volume_capabilities = 2;
+
+  // If specified, the Plugin SHALL report the capacity of the storage
+  // that can be used to provision volumes with the given Plugin
+  // specific `parameters`. These are the same `parameters` the CO will
+  // use in `CreateVolumeRequest`. This field is OPTIONAL.
+  map<string, string> parameters = 3;
+}
+
+message GetCapacityResponse {
+  // The available capacity of the storage that can be used to
+  // provision volumes. If `volume_capabilities` or `parameters` is
+  // specified in the request, the Plugin SHALL take those into
+  // consideration when calculating the available capacity of the
+  // storage. This field is REQUIRED.
+  uint64 available_capacity = 1;
+}
+////////
+////////
+message ControllerProbeRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+}
+
+message ControllerProbeResponse {}
+////////
+////////
+message ControllerGetCapabilitiesRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+}
+
+message ControllerGetCapabilitiesResponse {
+  // All the capabilities that the controller service supports. This
+  // field is OPTIONAL.
+  repeated ControllerServiceCapability capabilities = 2;
+}
+
+// Specifies a capability of the controller service.
+message ControllerServiceCapability {
+  message RPC {
+    enum Type {
+      UNKNOWN = 0;
+      CREATE_DELETE_VOLUME = 1;
+      PUBLISH_UNPUBLISH_VOLUME = 2;
+      LIST_VOLUMES = 3;
+      GET_CAPACITY = 4;
+    }
+
+    Type type = 1;
+  }
+
+  oneof type {
+    // RPC that the controller supports.
+    RPC rpc = 1;
+  }
+}
+////////
+////////
+message NodePublishVolumeRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+
+  // The ID of the volume to publish. This field is REQUIRED.
+  string volume_id = 2;
+
+  // The CO SHALL set this field to the value returned by
+  // `ControllerPublishVolume` if the corresponding Controller Plugin
+  // has `PUBLISH_UNPUBLISH_VOLUME` controller capability, and SHALL be
+  // left unset if the corresponding Controller Plugin does not have
+  // this capability. This is an OPTIONAL field.
+  map<string, string> publish_volume_info = 3;
+
+  // The path to which the volume will be published. It MUST be an
+  // absolute path in the root filesystem of the process serving this
+  // request. The CO SHALL ensure uniqueness of target_path per volume.
+  // The CO SHALL ensure that the path exists, and that the process
+  // serving the request has `read` and `write` permissions to the path.
+  // This is a REQUIRED field.
+  string target_path = 4;
+
+  // The capability of the volume the CO expects the volume to have.
+  // This is a REQUIRED field.
+  VolumeCapability volume_capability = 5;
+
+  // Whether to publish the volume in readonly mode. This field is
+  // REQUIRED.
+  bool readonly = 6;
+
+  // End user credentials used to authenticate/authorize node
+  // publish request.
+  // This field contains credential data, for example username and
+  // password. Each key must consist of alphanumeric characters, '-',
+  // '_' or '.'. Each value MUST contain a valid string. An SP MAY
+  // choose to accept binary (non-string) data by using a binary-to-text
+  // encoding scheme, like base64. An SP SHALL advertise the
+  // requirements for credentials in documentation. COs SHALL permit
+  // users to pass through the required credentials. This information is
+  // sensitive and MUST be treated as such (not logged, etc.) by the CO.
+  // This field is OPTIONAL.
+  map<string, string> user_credentials = 7;
+
+  // Attributes of the volume to publish. This field is OPTIONAL and
+  // MUST match the attributes of the VolumeInfo identified by
+  // `volume_id`.
+  map<string,string> volume_attributes = 8;
+}
+
+message NodePublishVolumeResponse {}
+////////
+////////
+message NodeUnpublishVolumeRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+
+  // The ID of the volume. This field is REQUIRED.
+  string volume_id = 2;
+
+  // The path at which the volume was published. It MUST be an absolute
+  // path in the root filesystem of the process serving this request.
+  // This is a REQUIRED field.
+  string target_path = 3;
+
+  // End user credentials used to authenticate/authorize node
+  // unpublish request.
+  // This field contains credential data, for example username and
+  // password. Each key must consist of alphanumeric characters, '-',
+  // '_' or '.'. Each value MUST contain a valid string. An SP MAY
+  // choose to accept binary (non-string) data by using a binary-to-text
+  // encoding scheme, like base64. An SP SHALL advertise the
+  // requirements for credentials in documentation. COs SHALL permit
+  // users to pass through the required credentials. This information is
+  // sensitive and MUST be treated as such (not logged, etc.) by the CO.
+  // This field is OPTIONAL.
+  map<string, string> user_credentials = 4;
+}
+
+message NodeUnpublishVolumeResponse {}
+////////
+////////
+message GetNodeIDRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+}
+
+message GetNodeIDResponse {
+  // The ID of the node as understood by the SP which SHALL be used by
+  // CO in subsequent `ControllerPublishVolume`.
+  // This is a REQUIRED field.
+  string node_id = 1;
+}
+////////
+////////
+message NodeProbeRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+}
+
+message NodeProbeResponse {}
+////////
+////////
+message NodeGetCapabilitiesRequest {
+  // The API version assumed by the CO. This is a REQUIRED field.
+  Version version = 1;
+}
+
+message NodeGetCapabilitiesResponse {
+  // All the capabilities that the node service supports. This field
+  // is OPTIONAL.
+  repeated NodeServiceCapability capabilities = 1;
+}
+
+// Specifies a capability of the node service.
+message NodeServiceCapability {
+  message RPC {
+    enum Type {
+      UNKNOWN = 0;
+    }
+
+    Type type = 1;
+  }
+
+  oneof type {
+    // RPC that the controller supports.
+    RPC rpc = 1;
+  }
+}
+////////
--- a/vendor/github.com/container-storage-interface/spec/lib/README.md
+++ b/vendor/github.com/container-storage-interface/spec/lib/README.md
@ -0,0 +1,2 @@
+# CSI Validation Libraries
+This directory contains language bindings generated from the CSI [protobuf file](../csi.proto) used to validate the model and workflows of the CSI specification.
--- a/vendor/github.com/container-storage-interface/spec/lib/cxx/Makefile
+++ b/vendor/github.com/container-storage-interface/spec/lib/cxx/Makefile
@ -0,0 +1,9 @@
+all: build
+
+build:
+	@echo "cxx bindings & validation"
+
+clean:
+	@echo "clean cxx"
+
+.PHONY: clean
--- a/vendor/github.com/container-storage-interface/spec/lib/go/.gitignore
+++ b/vendor/github.com/container-storage-interface/spec/lib/go/.gitignore
@ -0,0 +1,4 @@
+/protoc
+/protoc-gen-go
+/csi.a
+/csi/.build/
--- a/vendor/github.com/container-storage-interface/spec/lib/go/Makefile
+++ b/vendor/github.com/container-storage-interface/spec/lib/go/Makefile
@ -0,0 +1,119 @@
+all: build
+
+########################################################################
+##                             GOLANG                                 ##
+########################################################################
+
+# If GOPATH isn't defined then set its default location.
+ifeq (,$(strip $(GOPATH)))
+GOPATH := $(HOME)/go
+else
+# If GOPATH is already set then update GOPATH to be its own
+# first element.
+GOPATH := $(word 1,$(subst :, ,$(GOPATH)))
+endif
+export GOPATH
+
+
+########################################################################
+##                             PROTOC                                 ##
+########################################################################
+
+# Only set PROTOC_VER if it has an empty value.
+ifeq (,$(strip $(PROTOC_VER)))
+PROTOC_VER := 3.3.0
+endif
+
+PROTOC_OS := $(shell uname -s)
+ifeq (Darwin,$(PROTOC_OS))
+PROTOC_OS := osx
+endif
+
+PROTOC_ARCH := $(shell uname -m)
+ifeq (i386,$(PROTOC_ARCH))
+PROTOC_ARCH := x86_32
+endif
+
+PROTOC := ./protoc
+PROTOC_ZIP := protoc-$(PROTOC_VER)-$(PROTOC_OS)-$(PROTOC_ARCH).zip
+PROTOC_URL := https://github.com/google/protobuf/releases/download/v$(PROTOC_VER)/$(PROTOC_ZIP)
+PROTOC_TMP_DIR := .protoc
+PROTOC_TMP_BIN := $(PROTOC_TMP_DIR)/bin/protoc
+
+$(PROTOC):
+	-mkdir -p "$(PROTOC_TMP_DIR)" && \
+	  curl -L $(PROTOC_URL) -o "$(PROTOC_TMP_DIR)/$(PROTOC_ZIP)" && \
+	  unzip "$(PROTOC_TMP_DIR)/$(PROTOC_ZIP)" -d "$(PROTOC_TMP_DIR)" && \
+	  chmod 0755 "$(PROTOC_TMP_BIN)" && \
+	  cp -f "$(PROTOC_TMP_BIN)" "$@"
+	-rm -fr "$(PROTOC_TMP_DIR)"
+	stat "$@" > /dev/null 2>&1
+
+
+########################################################################
+##                          PROTOC-GEN-GO                             ##
+########################################################################
+
+# This is the recipe for getting and installing the go plug-in
+# for protoc
+PROTOC_GEN_GO_PKG := github.com/golang/protobuf/protoc-gen-go
+PROTOC_GEN_GO := protoc-gen-go
+$(PROTOC_GEN_GO):
+	go get -d $(PROTOC_GEN_GO_PKG) && \
+	go build -o "$@" $(PROTOC_GEN_GO_PKG)
+
+
+########################################################################
+##                              PATH                                  ##
+########################################################################
+
+# Update PATH with the current directory. This enables the protoc
+# binary to discover the protoc-gen-go binary, built inside this
+# directory.
+export PATH := $(shell pwd):$(PATH)
+
+
+########################################################################
+##                              BUILD                                 ##
+########################################################################
+CSI_GO := csi/csi.pb.go
+CSI_A := csi.a
+CSI_PROTO := ../../csi.proto
+CSI_GO_TMP := csi/.build/csi.pb.go
+
+# This recipe generates the go language bindings to a temp area.
+$(CSI_GO_TMP): $(CSI_PROTO) | $(PROTOC) $(PROTOC_GEN_GO)
+	@mkdir -p "$(@D)"
+	$(PROTOC) -I "$(<D)" --go_out=plugins=grpc:"$(@D)" "$<"
+
+# The temp language bindings are compared to the ones that are
+# versioned. If they are different then it means the language
+# bindings were not updated prior to being committed.
+$(CSI_GO): $(CSI_GO_TMP)
+ifeq (true,$(TRAVIS))
+	diff "$@" "$?"
+else
+	@mkdir -p "$(@D)"
+	diff "$@" "$?" > /dev/null 2>&1 || cp -f "$?" "$@"
+endif
+
+# This recipe builds the Go archive from the sources in three steps:
+#
+#   1. Go get any missing dependencies.
+#   2. Cache the packages.
+#   3. Build the archive file.
+$(CSI_A): $(CSI_GO)
+	go get -d ./...
+	go install ./csi
+	go build -o "$@" ./csi
+
+build: $(CSI_A)
+
+clean:
+	go clean -i ./...
+	rm -f "$(CSI_A)"
+
+clobber: clean
+	rm -fr "$(PROTOC)" "$(PROTOC_GEN_GO)" "$(dir $(CSI_GO))"
+
+.PHONY: clean clobber
--- a/vendor/github.com/container-storage-interface/spec/lib/go/README.md
+++ b/vendor/github.com/container-storage-interface/spec/lib/go/README.md
@ -0,0 +1,21 @@
+# CSI Go Validation
+
+This package is used to validate the CSI specification with Go language bindings.
+
+## Build Reference
+
+To validate the Go language bindings against the current specification use the following command:
+
+```bash
+$ make
+```
+
+The above command will download the `protoc` and `protoc-gen-go` binaries if they are not present and then proceed to build the CSI Go language bindings.
+
+### Environment Variables
+
+The following table lists the environment variables that can be used to influence the behavior of the Makefile:
+
+| Name | Default Value | Description |
+|------|---------------|-------------|
+| `PROTOC_VER` | `3.3.0` | The version of the protoc binary. |
--- a/vendor/github.com/container-storage-interface/spec/lib/go/csi.go
+++ b/vendor/github.com/container-storage-interface/spec/lib/go/csi.go
@ -0,0 +1,5 @@
+// Package csi is the Container Storage Interface (CSI) specification
+// repository. This package contains no functional code, and this file
+// exists only to make it possible to import this repository with a Go
+// dependency manager such as Dep (https://github.com/golang/dep).
+package csi
--- a/vendor/github.com/container-storage-interface/spec/lib/go/csi/csi.pb.go
+++ b/vendor/github.com/container-storage-interface/spec/lib/go/csi/csi.pb.go
--- a/vendor/github.com/container-storage-interface/spec/logo.png
+++ b/vendor/github.com/container-storage-interface/spec/logo.png
--- a/vendor/github.com/container-storage-interface/spec/spec.md
+++ b/vendor/github.com/container-storage-interface/spec/spec.md
--- a/vendor/github.com/emicklei/go-restful/.gitignore
+++ b/vendor/github.com/emicklei/go-restful/.gitignore
@ -0,0 +1,70 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+
+restful.html
+
+*.out
+
+tmp.prof
+
+go-restful.test
+
+examples/restful-basic-authentication
+
+examples/restful-encoding-filter
+
+examples/restful-filters
+
+examples/restful-hello-world
+
+examples/restful-resource-functions
+
+examples/restful-serve-static
+
+examples/restful-user-service
+
+*.DS_Store
+examples/restful-user-resource
+
+examples/restful-multi-containers
+
+examples/restful-form-handling
+
+examples/restful-CORS-filter
+
+examples/restful-options-filter
+
+examples/restful-curly-router
+
+examples/restful-cpuprofiler-service
+
+examples/restful-pre-post-filters
+
+curly.prof
+
+examples/restful-NCSA-logging
+
+examples/restful-html-template
+
+s.html
+restful-path-tail
--- a/vendor/github.com/emicklei/go-restful/.travis.yml
+++ b/vendor/github.com/emicklei/go-restful/.travis.yml
@ -0,0 +1,6 @@
+language: go
+
+go:
+  - 1.x
+
+script: go test -v
--- a/vendor/github.com/emicklei/go-restful/CHANGES.md
+++ b/vendor/github.com/emicklei/go-restful/CHANGES.md
@ -0,0 +1,226 @@
+Change history of go-restful
+=
+2017-09-13
+- added route condition functions using `.If(func)` in route building.
+
+2017-02-16
+- solved issue #304, make operation names unique
+
+2017-01-30
+ 
+	[IMPORTANT] For swagger users, change your import statement to:	
+	swagger "github.com/emicklei/go-restful-swagger12"
+
+- moved swagger 1.2 code to go-restful-swagger12
+- created TAG 2.0.0
+
+2017-01-27
+
+- remove defer request body close
+- expose Dispatch for testing filters and Routefunctions
+- swagger response model cannot be array 
+- created TAG 1.0.0
+
+2016-12-22
+
+- (API change) Remove code related to caching request content. Removes SetCacheReadEntity(doCache bool)
+
+2016-11-26
+
+- Default change! now use CurlyRouter (was RouterJSR311)
+- Default change! no more caching of request content
+- Default change! do not recover from panics
+
+2016-09-22
+
+- fix the DefaultRequestContentType feature
+
+2016-02-14
+
+- take the qualify factor of the Accept header mediatype into account when deciding the contentype of the response
+- add constructors for custom entity accessors for xml and json 
+
+2015-09-27
+
+- rename new WriteStatusAnd... to WriteHeaderAnd... for consistency
+
+2015-09-25
+
+- fixed problem with changing Header after WriteHeader (issue 235)
+
+2015-09-14
+
+- changed behavior of WriteHeader (immediate write) and WriteEntity (no status write)
+- added support for custom EntityReaderWriters.
+
+2015-08-06
+
+- add support for reading entities from compressed request content
+- use sync.Pool for compressors of http response and request body
+- add Description to Parameter for documentation in Swagger UI
+
+2015-03-20
+
+- add configurable logging
+
+2015-03-18
+
+- if not specified, the Operation is derived from the Route function
+
+2015-03-17
+
+- expose Parameter creation functions
+- make trace logger an interface
+- fix OPTIONSFilter
+- customize rendering of ServiceError
+- JSR311 router now handles wildcards
+- add Notes to Route
+
+2014-11-27
+
+- (api add) PrettyPrint per response. (as proposed in #167)
+
+2014-11-12
+
+- (api add) ApiVersion(.) for documentation in Swagger UI
+
+2014-11-10
+
+- (api change) struct fields tagged with "description" show up in Swagger UI
+
+2014-10-31
+
+- (api change) ReturnsError -> Returns
+- (api add)    RouteBuilder.Do(aBuilder) for DRY use of RouteBuilder
+- fix swagger nested structs
+- sort Swagger response messages by code
+
+2014-10-23
+
+- (api add) ReturnsError allows you to document Http codes in swagger
+- fixed problem with greedy CurlyRouter
+- (api add) Access-Control-Max-Age in CORS
+- add tracing functionality (injectable) for debugging purposes
+- support JSON parse 64bit int 
+- fix empty parameters for swagger
+- WebServicesUrl is now optional for swagger
+- fixed duplicate AccessControlAllowOrigin in CORS
+- (api change) expose ServeMux in container
+- (api add) added AllowedDomains in CORS
+- (api add) ParameterNamed for detailed documentation
+
+2014-04-16
+
+- (api add) expose constructor of Request for testing.
+
+2014-06-27
+
+- (api add) ParameterNamed gives access to a Parameter definition and its data (for further specification).
+- (api add) SetCacheReadEntity allow scontrol over whether or not the request body is being cached (default true for compatibility reasons).
+
+2014-07-03
+
+- (api add) CORS can be configured with a list of allowed domains
+
+2014-03-12
+
+- (api add) Route path parameters can use wildcard or regular expressions. (requires CurlyRouter)
+
+2014-02-26
+
+- (api add) Request now provides information about the matched Route, see method SelectedRoutePath 
+
+2014-02-17
+
+- (api change) renamed parameter constants (go-lint checks)
+
+2014-01-10
+
+- (api add) support for CloseNotify, see http://golang.org/pkg/net/http/#CloseNotifier
+
+2014-01-07
+
+- (api change) Write* methods in Response now return the error or nil.
+- added example of serving HTML from a Go template.
+- fixed comparing Allowed headers in CORS (is now case-insensitive)
+
+2013-11-13
+
+- (api add) Response knows how many bytes are written to the response body.
+
+2013-10-29
+
+- (api add) RecoverHandler(handler RecoverHandleFunction) to change how panic recovery is handled. Default behavior is to log and return a stacktrace. This may be a security issue as it exposes sourcecode information.
+
+2013-10-04
+
+- (api add) Response knows what HTTP status has been written
+- (api add) Request can have attributes (map of string->interface, also called request-scoped variables
+
+2013-09-12
+
+- (api change) Router interface simplified
+- Implemented CurlyRouter, a Router that does not use|allow regular expressions in paths
+
+2013-08-05
+ - add OPTIONS support
+ - add CORS support
+
+2013-08-27
+
+- fixed some reported issues (see github)
+- (api change) deprecated use of WriteError; use WriteErrorString instead
+
+2014-04-15
+
+- (fix) v1.0.1 tag: fix Issue 111: WriteErrorString
+
+2013-08-08
+
+- (api add) Added implementation Container: a WebServices collection with its own http.ServeMux allowing multiple endpoints per program. Existing uses of go-restful will register their services to the DefaultContainer.
+- (api add) the swagger package has be extended to have a UI per container.
+- if panic is detected then a small stack trace is printed (thanks to runner-mei)
+- (api add) WriteErrorString to Response
+
+Important API changes:
+
+- (api remove) package variable DoNotRecover no longer works ; use restful.DefaultContainer.DoNotRecover(true) instead.
+- (api remove) package variable EnableContentEncoding no longer works ; use restful.DefaultContainer.EnableContentEncoding(true) instead.
+ 
+ 
+2013-07-06
+
+- (api add) Added support for response encoding (gzip and deflate(zlib)). This feature is disabled on default (for backwards compatibility). Use restful.EnableContentEncoding = true in your initialization to enable this feature.
+
+2013-06-19
+
+- (improve) DoNotRecover option, moved request body closer, improved ReadEntity
+
+2013-06-03
+
+- (api change) removed Dispatcher interface, hide PathExpression
+- changed receiver names of type functions to be more idiomatic Go
+
+2013-06-02
+
+- (optimize) Cache the RegExp compilation of Paths.
+
+2013-05-22
+	
+- (api add) Added support for request/response filter functions
+
+2013-05-18
+
+
+- (api add) Added feature to change the default Http Request Dispatch function (travis cline)
+- (api change) Moved Swagger Webservice to swagger package (see example restful-user)
+
+[2012-11-14 .. 2013-05-18>
+ 
+- See https://github.com/emicklei/go-restful/commits
+
+2012-11-14
+
+- Initial commit
+
+
--- a/vendor/github.com/emicklei/go-restful/LICENSE
+++ b/vendor/github.com/emicklei/go-restful/LICENSE
@ -0,0 +1,22 @@
+Copyright (c) 2012,2013 Ernest Micklei
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/emicklei/go-restful/Makefile
+++ b/vendor/github.com/emicklei/go-restful/Makefile
@ -0,0 +1,7 @@
+all: test
+
+test:
+	go test -v .
+
+ex:
+	cd examples && ls *.go | xargs go build -o /tmp/ignore
--- a/vendor/github.com/emicklei/go-restful/README.md
+++ b/vendor/github.com/emicklei/go-restful/README.md
@ -0,0 +1,75 @@
+go-restful
+==========
+package for building REST-style Web Services using Google Go
+
+[![Build Status](https://travis-ci.org/emicklei/go-restful.png)](https://travis-ci.org/emicklei/go-restful)
+[![Go Report Card](https://goreportcard.com/badge/github.com/emicklei/go-restful)](https://goreportcard.com/report/github.com/emicklei/go-restful)
+[![GoDoc](https://godoc.org/github.com/emicklei/go-restful?status.svg)](https://godoc.org/github.com/emicklei/go-restful)
+
+- [Code examples](https://github.com/emicklei/go-restful/tree/master/examples)
+
+REST asks developers to use HTTP methods explicitly and in a way that's consistent with the protocol definition. This basic REST design principle establishes a one-to-one mapping between create, read, update, and delete (CRUD) operations and HTTP methods. According to this mapping:
+
+- GET = Retrieve a representation of a resource
+- POST = Create if you are sending content to the server to create a subordinate of the specified resource collection, using some server-side algorithm.
+- PUT = Create if you are sending the full content of the specified resource (URI).
+- PUT = Update if you are updating the full content of the specified resource.
+- DELETE = Delete if you are requesting the server to delete the resource
+- PATCH = Update partial content of a resource
+- OPTIONS = Get information about the communication options for the request URI
+    
+### Example
+
+```Go
+ws := new(restful.WebService)
+ws.
+	Path("/users").
+	Consumes(restful.MIME_XML, restful.MIME_JSON).
+	Produces(restful.MIME_JSON, restful.MIME_XML)
+
+ws.Route(ws.GET("/{user-id}").To(u.findUser).
+	Doc("get a user").
+	Param(ws.PathParameter("user-id", "identifier of the user").DataType("string")).
+	Writes(User{}))		
+...
+	
+func (u UserResource) findUser(request *restful.Request, response *restful.Response) {
+	id := request.PathParameter("user-id")
+	...
+}
+```
+	
+[Full API of a UserResource](https://github.com/emicklei/go-restful/tree/master/examples/restful-user-resource.go) 
+		
+### Features
+
+- Routes for request &#8594; function mapping with path parameter (e.g. {id}) support
+- Configurable router:
+	- (default) Fast routing algorithm that allows static elements, regular expressions and dynamic parameters in the URL path (e.g. /meetings/{id} or /static/{subpath:*}
+	- Routing algorithm after [JSR311](http://jsr311.java.net/nonav/releases/1.1/spec/spec.html) that is implemented using (but does **not** accept) regular expressions
+- Request API for reading structs from JSON/XML and accesing parameters (path,query,header)
+- Response API for writing structs to JSON/XML and setting headers
+- Customizable encoding using EntityReaderWriter registration
+- Filters for intercepting the request &#8594; response flow on Service or Route level
+- Request-scoped variables using attributes
+- Containers for WebServices on different HTTP endpoints
+- Content encoding (gzip,deflate) of request and response payloads
+- Automatic responses on OPTIONS (using a filter)
+- Automatic CORS request handling (using a filter)
+- API declaration for Swagger UI ([go-restful-openapi](https://github.com/emicklei/go-restful-openapi), see [go-restful-swagger12](https://github.com/emicklei/go-restful-swagger12))
+- Panic recovery to produce HTTP 500, customizable using RecoverHandler(...)
+- Route errors produce HTTP 404/405/406/415 errors, customizable using ServiceErrorHandler(...)
+- Configurable (trace) logging
+- Customizable gzip/deflate readers and writers using CompressorProvider registration
+	
+### Resources
+
+- [Example posted on blog](http://ernestmicklei.com/2012/11/go-restful-first-working-example/)
+- [Design explained on blog](http://ernestmicklei.com/2012/11/go-restful-api-design/)
+- [sourcegraph](https://sourcegraph.com/github.com/emicklei/go-restful)
+- [showcase: Zazkia - tcp proxy for testing resiliency](https://github.com/emicklei/zazkia)
+- [showcase: Mora - MongoDB REST Api server](https://github.com/emicklei/mora)
+
+Type ```git shortlog -s``` for a full list of contributors.
+
+© 2012 - 2017, http://ernestmicklei.com. MIT License. Contributions are welcome.
--- a/vendor/github.com/emicklei/go-restful/Srcfile
+++ b/vendor/github.com/emicklei/go-restful/Srcfile
@ -0,0 +1 @@
+{"SkipDirs": ["examples"]}
--- a/vendor/github.com/emicklei/go-restful/bench_curly_test.go
+++ b/vendor/github.com/emicklei/go-restful/bench_curly_test.go
@ -0,0 +1,51 @@
+package restful
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func setupCurly(container *Container) []string {
+	wsCount := 26
+	rtCount := 26
+	urisCurly := []string{}
+
+	container.Router(CurlyRouter{})
+	for i := 0; i < wsCount; i++ {
+		root := fmt.Sprintf("/%s/{%s}/", string(i+97), string(i+97))
+		ws := new(WebService).Path(root)
+		for j := 0; j < rtCount; j++ {
+			sub := fmt.Sprintf("/%s2/{%s2}", string(j+97), string(j+97))
+			ws.Route(ws.GET(sub).Consumes("application/xml").Produces("application/xml").To(echoCurly))
+		}
+		container.Add(ws)
+		for _, each := range ws.Routes() {
+			urisCurly = append(urisCurly, "http://bench.com"+each.Path)
+		}
+	}
+	return urisCurly
+}
+
+func echoCurly(req *Request, resp *Response) {}
+
+func BenchmarkManyCurly(b *testing.B) {
+	container := NewContainer()
+	urisCurly := setupCurly(container)
+	b.ResetTimer()
+	for t := 0; t < b.N; t++ {
+		for r := 0; r < 1000; r++ {
+			for _, each := range urisCurly {
+				sendNoReturnTo(each, container, t)
+			}
+		}
+	}
+}
+
+func sendNoReturnTo(address string, container *Container, t int) {
+	httpRequest, _ := http.NewRequest("GET", address, nil)
+	httpRequest.Header.Set("Accept", "application/xml")
+	httpWriter := httptest.NewRecorder()
+	container.dispatch(httpWriter, httpRequest)
+}
--- a/vendor/github.com/emicklei/go-restful/bench_test.go
+++ b/vendor/github.com/emicklei/go-restful/bench_test.go
@ -0,0 +1,43 @@
+package restful
+
+import (
+	"fmt"
+	"io"
+	"testing"
+)
+
+var uris = []string{}
+
+func setup(container *Container) {
+	wsCount := 26
+	rtCount := 26
+
+	for i := 0; i < wsCount; i++ {
+		root := fmt.Sprintf("/%s/{%s}/", string(i+97), string(i+97))
+		ws := new(WebService).Path(root)
+		for j := 0; j < rtCount; j++ {
+			sub := fmt.Sprintf("/%s2/{%s2}", string(j+97), string(j+97))
+			ws.Route(ws.GET(sub).To(echo))
+		}
+		container.Add(ws)
+		for _, each := range ws.Routes() {
+			uris = append(uris, "http://bench.com"+each.Path)
+		}
+	}
+}
+
+func echo(req *Request, resp *Response) {
+	io.WriteString(resp.ResponseWriter, "echo")
+}
+
+func BenchmarkMany(b *testing.B) {
+	container := NewContainer()
+	setup(container)
+	b.ResetTimer()
+	for t := 0; t < b.N; t++ {
+		for _, each := range uris {
+			// println(each)
+			sendItTo(each, container)
+		}
+	}
+}
--- a/vendor/github.com/emicklei/go-restful/bench_test.sh
+++ b/vendor/github.com/emicklei/go-restful/bench_test.sh
@ -0,0 +1,10 @@
+#go test -run=none -file bench_test.go -test.bench . -cpuprofile=bench_test.out
+
+go test -c
+./go-restful.test -test.run=none -test.cpuprofile=tmp.prof -test.bench=BenchmarkMany
+./go-restful.test -test.run=none -test.cpuprofile=curly.prof -test.bench=BenchmarkManyCurly
+
+#go tool pprof go-restful.test tmp.prof
+go tool pprof go-restful.test curly.prof
+
+
--- a/vendor/github.com/emicklei/go-restful/compress.go
+++ b/vendor/github.com/emicklei/go-restful/compress.go
@ -0,0 +1,123 @@
+package restful
+
+// Copyright 2013 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+import (
+	"bufio"
+	"compress/gzip"
+	"compress/zlib"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+)
+
+// OBSOLETE : use restful.DefaultContainer.EnableContentEncoding(true) to change this setting.
+var EnableContentEncoding = false
+
+// CompressingResponseWriter is a http.ResponseWriter that can perform content encoding (gzip and zlib)
+type CompressingResponseWriter struct {
+	writer     http.ResponseWriter
+	compressor io.WriteCloser
+	encoding   string
+}
+
+// Header is part of http.ResponseWriter interface
+func (c *CompressingResponseWriter) Header() http.Header {
+	return c.writer.Header()
+}
+
+// WriteHeader is part of http.ResponseWriter interface
+func (c *CompressingResponseWriter) WriteHeader(status int) {
+	c.writer.WriteHeader(status)
+}
+
+// Write is part of http.ResponseWriter interface
+// It is passed through the compressor
+func (c *CompressingResponseWriter) Write(bytes []byte) (int, error) {
+	if c.isCompressorClosed() {
+		return -1, errors.New("Compressing error: tried to write data using closed compressor")
+	}
+	return c.compressor.Write(bytes)
+}
+
+// CloseNotify is part of http.CloseNotifier interface
+func (c *CompressingResponseWriter) CloseNotify() <-chan bool {
+	return c.writer.(http.CloseNotifier).CloseNotify()
+}
+
+// Close the underlying compressor
+func (c *CompressingResponseWriter) Close() error {
+	if c.isCompressorClosed() {
+		return errors.New("Compressing error: tried to close already closed compressor")
+	}
+
+	c.compressor.Close()
+	if ENCODING_GZIP == c.encoding {
+		currentCompressorProvider.ReleaseGzipWriter(c.compressor.(*gzip.Writer))
+	}
+	if ENCODING_DEFLATE == c.encoding {
+		currentCompressorProvider.ReleaseZlibWriter(c.compressor.(*zlib.Writer))
+	}
+	// gc hint needed?
+	c.compressor = nil
+	return nil
+}
+
+func (c *CompressingResponseWriter) isCompressorClosed() bool {
+	return nil == c.compressor
+}
+
+// Hijack implements the Hijacker interface
+// This is especially useful when combining Container.EnabledContentEncoding
+// in combination with websockets (for instance gorilla/websocket)
+func (c *CompressingResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hijacker, ok := c.writer.(http.Hijacker)
+	if !ok {
+		return nil, nil, errors.New("ResponseWriter doesn't support Hijacker interface")
+	}
+	return hijacker.Hijack()
+}
+
+// WantsCompressedResponse reads the Accept-Encoding header to see if and which encoding is requested.
+func wantsCompressedResponse(httpRequest *http.Request) (bool, string) {
+	header := httpRequest.Header.Get(HEADER_AcceptEncoding)
+	gi := strings.Index(header, ENCODING_GZIP)
+	zi := strings.Index(header, ENCODING_DEFLATE)
+	// use in order of appearance
+	if gi == -1 {
+		return zi != -1, ENCODING_DEFLATE
+	} else if zi == -1 {
+		return gi != -1, ENCODING_GZIP
+	} else {
+		if gi < zi {
+			return true, ENCODING_GZIP
+		}
+		return true, ENCODING_DEFLATE
+	}
+}
+
+// NewCompressingResponseWriter create a CompressingResponseWriter for a known encoding = {gzip,deflate}
+func NewCompressingResponseWriter(httpWriter http.ResponseWriter, encoding string) (*CompressingResponseWriter, error) {
+	httpWriter.Header().Set(HEADER_ContentEncoding, encoding)
+	c := new(CompressingResponseWriter)
+	c.writer = httpWriter
+	var err error
+	if ENCODING_GZIP == encoding {
+		w := currentCompressorProvider.AcquireGzipWriter()
+		w.Reset(httpWriter)
+		c.compressor = w
+		c.encoding = ENCODING_GZIP
+	} else if ENCODING_DEFLATE == encoding {
+		w := currentCompressorProvider.AcquireZlibWriter()
+		w.Reset(httpWriter)
+		c.compressor = w
+		c.encoding = ENCODING_DEFLATE
+	} else {
+		return nil, errors.New("Unknown encoding:" + encoding)
+	}
+	return c, err
+}
--- a/vendor/github.com/emicklei/go-restful/compress_test.go
+++ b/vendor/github.com/emicklei/go-restful/compress_test.go
@ -0,0 +1,125 @@
+package restful
+
+import (
+	"bytes"
+	"compress/gzip"
+	"compress/zlib"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// go test -v -test.run TestGzip ...restful
+func TestGzip(t *testing.T) {
+	EnableContentEncoding = true
+	httpRequest, _ := http.NewRequest("GET", "/test", nil)
+	httpRequest.Header.Set("Accept-Encoding", "gzip,deflate")
+	httpWriter := httptest.NewRecorder()
+	wanted, encoding := wantsCompressedResponse(httpRequest)
+	if !wanted {
+		t.Fatal("should accept gzip")
+	}
+	if encoding != "gzip" {
+		t.Fatal("expected gzip")
+	}
+	c, err := NewCompressingResponseWriter(httpWriter, encoding)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	c.Write([]byte("Hello World"))
+	c.Close()
+	if httpWriter.Header().Get("Content-Encoding") != "gzip" {
+		t.Fatal("Missing gzip header")
+	}
+	reader, err := gzip.NewReader(httpWriter.Body)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	data, err := ioutil.ReadAll(reader)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if got, want := string(data), "Hello World"; got != want {
+		t.Errorf("got %v want %v", got, want)
+	}
+}
+
+func TestDeflate(t *testing.T) {
+	EnableContentEncoding = true
+	httpRequest, _ := http.NewRequest("GET", "/test", nil)
+	httpRequest.Header.Set("Accept-Encoding", "deflate,gzip")
+	httpWriter := httptest.NewRecorder()
+	wanted, encoding := wantsCompressedResponse(httpRequest)
+	if !wanted {
+		t.Fatal("should accept deflate")
+	}
+	if encoding != "deflate" {
+		t.Fatal("expected deflate")
+	}
+	c, err := NewCompressingResponseWriter(httpWriter, encoding)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	c.Write([]byte("Hello World"))
+	c.Close()
+	if httpWriter.Header().Get("Content-Encoding") != "deflate" {
+		t.Fatal("Missing deflate header")
+	}
+	reader, err := zlib.NewReader(httpWriter.Body)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	data, err := ioutil.ReadAll(reader)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if got, want := string(data), "Hello World"; got != want {
+		t.Errorf("got %v want %v", got, want)
+	}
+}
+
+func TestGzipDecompressRequestBody(t *testing.T) {
+	b := new(bytes.Buffer)
+	w := newGzipWriter()
+	w.Reset(b)
+	io.WriteString(w, `{"msg":"hi"}`)
+	w.Flush()
+	w.Close()
+
+	req := new(Request)
+	httpRequest, _ := http.NewRequest("GET", "/", bytes.NewReader(b.Bytes()))
+	httpRequest.Header.Set("Content-Type", "application/json")
+	httpRequest.Header.Set("Content-Encoding", "gzip")
+	req.Request = httpRequest
+
+	doc := make(map[string]interface{})
+	req.ReadEntity(&doc)
+
+	if got, want := doc["msg"], "hi"; got != want {
+		t.Errorf("got %v want %v", got, want)
+	}
+}
+
+func TestZlibDecompressRequestBody(t *testing.T) {
+	b := new(bytes.Buffer)
+	w := newZlibWriter()
+	w.Reset(b)
+	io.WriteString(w, `{"msg":"hi"}`)
+	w.Flush()
+	w.Close()
+
+	req := new(Request)
+	httpRequest, _ := http.NewRequest("GET", "/", bytes.NewReader(b.Bytes()))
+	httpRequest.Header.Set("Content-Type", "application/json")
+	httpRequest.Header.Set("Content-Encoding", "deflate")
+	req.Request = httpRequest
+
+	doc := make(map[string]interface{})
+	req.ReadEntity(&doc)
+
+	if got, want := doc["msg"], "hi"; got != want {
+		t.Errorf("got %v want %v", got, want)
+	}
+}
--- a/vendor/github.com/emicklei/go-restful/compressor_cache.go
+++ b/vendor/github.com/emicklei/go-restful/compressor_cache.go
@ -0,0 +1,103 @@
+package restful
+
+// Copyright 2015 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+import (
+	"compress/gzip"
+	"compress/zlib"
+)
+
+// BoundedCachedCompressors is a CompressorProvider that uses a cache with a fixed amount
+// of writers and readers (resources).
+// If a new resource is acquired and all are in use, it will return a new unmanaged resource.
+type BoundedCachedCompressors struct {
+	gzipWriters     chan *gzip.Writer
+	gzipReaders     chan *gzip.Reader
+	zlibWriters     chan *zlib.Writer
+	writersCapacity int
+	readersCapacity int
+}
+
+// NewBoundedCachedCompressors returns a new, with filled cache,  BoundedCachedCompressors.
+func NewBoundedCachedCompressors(writersCapacity, readersCapacity int) *BoundedCachedCompressors {
+	b := &BoundedCachedCompressors{
+		gzipWriters:     make(chan *gzip.Writer, writersCapacity),
+		gzipReaders:     make(chan *gzip.Reader, readersCapacity),
+		zlibWriters:     make(chan *zlib.Writer, writersCapacity),
+		writersCapacity: writersCapacity,
+		readersCapacity: readersCapacity,
+	}
+	for ix := 0; ix < writersCapacity; ix++ {
+		b.gzipWriters <- newGzipWriter()
+		b.zlibWriters <- newZlibWriter()
+	}
+	for ix := 0; ix < readersCapacity; ix++ {
+		b.gzipReaders <- newGzipReader()
+	}
+	return b
+}
+
+// AcquireGzipWriter returns an resettable *gzip.Writer. Needs to be released.
+func (b *BoundedCachedCompressors) AcquireGzipWriter() *gzip.Writer {
+	var writer *gzip.Writer
+	select {
+	case writer, _ = <-b.gzipWriters:
+	default:
+		// return a new unmanaged one
+		writer = newGzipWriter()
+	}
+	return writer
+}
+
+// ReleaseGzipWriter accepts a writer (does not have to be one that was cached)
+// only when the cache has room for it. It will ignore it otherwise.
+func (b *BoundedCachedCompressors) ReleaseGzipWriter(w *gzip.Writer) {
+	// forget the unmanaged ones
+	if len(b.gzipWriters) < b.writersCapacity {
+		b.gzipWriters <- w
+	}
+}
+
+// AcquireGzipReader returns a *gzip.Reader. Needs to be released.
+func (b *BoundedCachedCompressors) AcquireGzipReader() *gzip.Reader {
+	var reader *gzip.Reader
+	select {
+	case reader, _ = <-b.gzipReaders:
+	default:
+		// return a new unmanaged one
+		reader = newGzipReader()
+	}
+	return reader
+}
+
+// ReleaseGzipReader accepts a reader (does not have to be one that was cached)
+// only when the cache has room for it. It will ignore it otherwise.
+func (b *BoundedCachedCompressors) ReleaseGzipReader(r *gzip.Reader) {
+	// forget the unmanaged ones
+	if len(b.gzipReaders) < b.readersCapacity {
+		b.gzipReaders <- r
+	}
+}
+
+// AcquireZlibWriter returns an resettable *zlib.Writer. Needs to be released.
+func (b *BoundedCachedCompressors) AcquireZlibWriter() *zlib.Writer {
+	var writer *zlib.Writer
+	select {
+	case writer, _ = <-b.zlibWriters:
+	default:
+		// return a new unmanaged one
+		writer = newZlibWriter()
+	}
+	return writer
+}
+
+// ReleaseZlibWriter accepts a writer (does not have to be one that was cached)
+// only when the cache has room for it. It will ignore it otherwise.
+func (b *BoundedCachedCompressors) ReleaseZlibWriter(w *zlib.Writer) {
+	// forget the unmanaged ones
+	if len(b.zlibWriters) < b.writersCapacity {
+		b.zlibWriters <- w
+	}
+}
--- a/vendor/github.com/emicklei/go-restful/compressor_pools.go
+++ b/vendor/github.com/emicklei/go-restful/compressor_pools.go
@ -0,0 +1,91 @@
+package restful
+
+// Copyright 2015 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+import (
+	"bytes"
+	"compress/gzip"
+	"compress/zlib"
+	"sync"
+)
+
+// SyncPoolCompessors is a CompressorProvider that use the standard sync.Pool.
+type SyncPoolCompessors struct {
+	GzipWriterPool *sync.Pool
+	GzipReaderPool *sync.Pool
+	ZlibWriterPool *sync.Pool
+}
+
+// NewSyncPoolCompessors returns a new ("empty") SyncPoolCompessors.
+func NewSyncPoolCompessors() *SyncPoolCompessors {
+	return &SyncPoolCompessors{
+		GzipWriterPool: &sync.Pool{
+			New: func() interface{} { return newGzipWriter() },
+		},
+		GzipReaderPool: &sync.Pool{
+			New: func() interface{} { return newGzipReader() },
+		},
+		ZlibWriterPool: &sync.Pool{
+			New: func() interface{} { return newZlibWriter() },
+		},
+	}
+}
+
+func (s *SyncPoolCompessors) AcquireGzipWriter() *gzip.Writer {
+	return s.GzipWriterPool.Get().(*gzip.Writer)
+}
+
+func (s *SyncPoolCompessors) ReleaseGzipWriter(w *gzip.Writer) {
+	s.GzipWriterPool.Put(w)
+}
+
+func (s *SyncPoolCompessors) AcquireGzipReader() *gzip.Reader {
+	return s.GzipReaderPool.Get().(*gzip.Reader)
+}
+
+func (s *SyncPoolCompessors) ReleaseGzipReader(r *gzip.Reader) {
+	s.GzipReaderPool.Put(r)
+}
+
+func (s *SyncPoolCompessors) AcquireZlibWriter() *zlib.Writer {
+	return s.ZlibWriterPool.Get().(*zlib.Writer)
+}
+
+func (s *SyncPoolCompessors) ReleaseZlibWriter(w *zlib.Writer) {
+	s.ZlibWriterPool.Put(w)
+}
+
+func newGzipWriter() *gzip.Writer {
+	// create with an empty bytes writer; it will be replaced before using the gzipWriter
+	writer, err := gzip.NewWriterLevel(new(bytes.Buffer), gzip.BestSpeed)
+	if err != nil {
+		panic(err.Error())
+	}
+	return writer
+}
+
+func newGzipReader() *gzip.Reader {
+	// create with an empty reader (but with GZIP header); it will be replaced before using the gzipReader
+	// we can safely use currentCompressProvider because it is set on package initialization.
+	w := currentCompressorProvider.AcquireGzipWriter()
+	defer currentCompressorProvider.ReleaseGzipWriter(w)
+	b := new(bytes.Buffer)
+	w.Reset(b)
+	w.Flush()
+	w.Close()
+	reader, err := gzip.NewReader(bytes.NewReader(b.Bytes()))
+	if err != nil {
+		panic(err.Error())
+	}
+	return reader
+}
+
+func newZlibWriter() *zlib.Writer {
+	writer, err := zlib.NewWriterLevel(new(bytes.Buffer), gzip.BestSpeed)
+	if err != nil {
+		panic(err.Error())
+	}
+	return writer
+}
--- a/vendor/github.com/emicklei/go-restful/compressors.go
+++ b/vendor/github.com/emicklei/go-restful/compressors.go
@ -0,0 +1,54 @@
+package restful
+
+// Copyright 2015 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+import (
+	"compress/gzip"
+	"compress/zlib"
+)
+
+// CompressorProvider describes a component that can provider compressors for the std methods.
+type CompressorProvider interface {
+	// Returns a *gzip.Writer which needs to be released later.
+	// Before using it, call Reset().
+	AcquireGzipWriter() *gzip.Writer
+
+	// Releases an acquired *gzip.Writer.
+	ReleaseGzipWriter(w *gzip.Writer)
+
+	// Returns a *gzip.Reader which needs to be released later.
+	AcquireGzipReader() *gzip.Reader
+
+	// Releases an acquired *gzip.Reader.
+	ReleaseGzipReader(w *gzip.Reader)
+
+	// Returns a *zlib.Writer which needs to be released later.
+	// Before using it, call Reset().
+	AcquireZlibWriter() *zlib.Writer
+
+	// Releases an acquired *zlib.Writer.
+	ReleaseZlibWriter(w *zlib.Writer)
+}
+
+// DefaultCompressorProvider is the actual provider of compressors (zlib or gzip).
+var currentCompressorProvider CompressorProvider
+
+func init() {
+	currentCompressorProvider = NewSyncPoolCompessors()
+}
+
+// CurrentCompressorProvider returns the current CompressorProvider.
+// It is initialized using a SyncPoolCompessors.
+func CurrentCompressorProvider() CompressorProvider {
+	return currentCompressorProvider
+}
+
+// SetCompressorProvider sets the actual provider of compressors (zlib or gzip).
+func SetCompressorProvider(p CompressorProvider) {
+	if p == nil {
+		panic("cannot set compressor provider to nil")
+	}
+	currentCompressorProvider = p
+}
--- a/vendor/github.com/emicklei/go-restful/constants.go
+++ b/vendor/github.com/emicklei/go-restful/constants.go
@ -0,0 +1,30 @@
+package restful
+
+// Copyright 2013 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+const (
+	MIME_XML   = "application/xml"          // Accept or Content-Type used in Consumes() and/or Produces()
+	MIME_JSON  = "application/json"         // Accept or Content-Type used in Consumes() and/or Produces()
+	MIME_OCTET = "application/octet-stream" // If Content-Type is not present in request, use the default
+
+	HEADER_Allow                         = "Allow"
+	HEADER_Accept                        = "Accept"
+	HEADER_Origin                        = "Origin"
+	HEADER_ContentType                   = "Content-Type"
+	HEADER_LastModified                  = "Last-Modified"
+	HEADER_AcceptEncoding                = "Accept-Encoding"
+	HEADER_ContentEncoding               = "Content-Encoding"
+	HEADER_AccessControlExposeHeaders    = "Access-Control-Expose-Headers"
+	HEADER_AccessControlRequestMethod    = "Access-Control-Request-Method"
+	HEADER_AccessControlRequestHeaders   = "Access-Control-Request-Headers"
+	HEADER_AccessControlAllowMethods     = "Access-Control-Allow-Methods"
+	HEADER_AccessControlAllowOrigin      = "Access-Control-Allow-Origin"
+	HEADER_AccessControlAllowCredentials = "Access-Control-Allow-Credentials"
+	HEADER_AccessControlAllowHeaders     = "Access-Control-Allow-Headers"
+	HEADER_AccessControlMaxAge           = "Access-Control-Max-Age"
+
+	ENCODING_GZIP    = "gzip"
+	ENCODING_DEFLATE = "deflate"
+)
--- a/vendor/github.com/emicklei/go-restful/container.go
+++ b/vendor/github.com/emicklei/go-restful/container.go
@ -0,0 +1,366 @@
+package restful
+
+// Copyright 2013 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+
+	"github.com/emicklei/go-restful/log"
+)
+
+// Container holds a collection of WebServices and a http.ServeMux to dispatch http requests.
+// The requests are further dispatched to routes of WebServices using a RouteSelector
+type Container struct {
+	webServicesLock        sync.RWMutex
+	webServices            []*WebService
+	ServeMux               *http.ServeMux
+	isRegisteredOnRoot     bool
+	containerFilters       []FilterFunction
+	doNotRecover           bool // default is true
+	recoverHandleFunc      RecoverHandleFunction
+	serviceErrorHandleFunc ServiceErrorHandleFunction
+	router                 RouteSelector // default is a CurlyRouter (RouterJSR311 is a slower alternative)
+	contentEncodingEnabled bool          // default is false
+}
+
+// NewContainer creates a new Container using a new ServeMux and default router (CurlyRouter)
+func NewContainer() *Container {
+	return &Container{
+		webServices:            []*WebService{},
+		ServeMux:               http.NewServeMux(),
+		isRegisteredOnRoot:     false,
+		containerFilters:       []FilterFunction{},
+		doNotRecover:           true,
+		recoverHandleFunc:      logStackOnRecover,
+		serviceErrorHandleFunc: writeServiceError,
+		router:                 CurlyRouter{},
+		contentEncodingEnabled: false}
+}
+
+// RecoverHandleFunction declares functions that can be used to handle a panic situation.
+// The first argument is what recover() returns. The second must be used to communicate an error response.
+type RecoverHandleFunction func(interface{}, http.ResponseWriter)
+
+// RecoverHandler changes the default function (logStackOnRecover) to be called
+// when a panic is detected. DoNotRecover must be have its default value (=false).
+func (c *Container) RecoverHandler(handler RecoverHandleFunction) {
+	c.recoverHandleFunc = handler
+}
+
+// ServiceErrorHandleFunction declares functions that can be used to handle a service error situation.
+// The first argument is the service error, the second is the request that resulted in the error and
+// the third must be used to communicate an error response.
+type ServiceErrorHandleFunction func(ServiceError, *Request, *Response)
+
+// ServiceErrorHandler changes the default function (writeServiceError) to be called
+// when a ServiceError is detected.
+func (c *Container) ServiceErrorHandler(handler ServiceErrorHandleFunction) {
+	c.serviceErrorHandleFunc = handler
+}
+
+// DoNotRecover controls whether panics will be caught to return HTTP 500.
+// If set to true, Route functions are responsible for handling any error situation.
+// Default value is true.
+func (c *Container) DoNotRecover(doNot bool) {
+	c.doNotRecover = doNot
+}
+
+// Router changes the default Router (currently CurlyRouter)
+func (c *Container) Router(aRouter RouteSelector) {
+	c.router = aRouter
+}
+
+// EnableContentEncoding (default=false) allows for GZIP or DEFLATE encoding of responses.
+func (c *Container) EnableContentEncoding(enabled bool) {
+	c.contentEncodingEnabled = enabled
+}
+
+// Add a WebService to the Container. It will detect duplicate root paths and exit in that case.
+func (c *Container) Add(service *WebService) *Container {
+	c.webServicesLock.Lock()
+	defer c.webServicesLock.Unlock()
+
+	// if rootPath was not set then lazy initialize it
+	if len(service.rootPath) == 0 {
+		service.Path("/")
+	}
+
+	// cannot have duplicate root paths
+	for _, each := range c.webServices {
+		if each.RootPath() == service.RootPath() {
+			log.Printf("[restful] WebService with duplicate root path detected:['%v']", each)
+			os.Exit(1)
+		}
+	}
+
+	// If not registered on root then add specific mapping
+	if !c.isRegisteredOnRoot {
+		c.isRegisteredOnRoot = c.addHandler(service, c.ServeMux)
+	}
+	c.webServices = append(c.webServices, service)
+	return c
+}
+
+// addHandler may set a new HandleFunc for the serveMux
+// this function must run inside the critical region protected by the webServicesLock.
+// returns true if the function was registered on root ("/")
+func (c *Container) addHandler(service *WebService, serveMux *http.ServeMux) bool {
+	pattern := fixedPrefixPath(service.RootPath())
+	// check if root path registration is needed
+	if "/" == pattern || "" == pattern {
+		serveMux.HandleFunc("/", c.dispatch)
+		return true
+	}
+	// detect if registration already exists
+	alreadyMapped := false
+	for _, each := range c.webServices {
+		if each.RootPath() == service.RootPath() {
+			alreadyMapped = true
+			break
+		}
+	}
+	if !alreadyMapped {
+		serveMux.HandleFunc(pattern, c.dispatch)
+		if !strings.HasSuffix(pattern, "/") {
+			serveMux.HandleFunc(pattern+"/", c.dispatch)
+		}
+	}
+	return false
+}
+
+func (c *Container) Remove(ws *WebService) error {
+	if c.ServeMux == http.DefaultServeMux {
+		errMsg := fmt.Sprintf("[restful] cannot remove a WebService from a Container using the DefaultServeMux: ['%v']", ws)
+		log.Print(errMsg)
+		return errors.New(errMsg)
+	}
+	c.webServicesLock.Lock()
+	defer c.webServicesLock.Unlock()
+	// build a new ServeMux and re-register all WebServices
+	newServeMux := http.NewServeMux()
+	newServices := []*WebService{}
+	newIsRegisteredOnRoot := false
+	for _, each := range c.webServices {
+		if each.rootPath != ws.rootPath {
+			// If not registered on root then add specific mapping
+			if !newIsRegisteredOnRoot {
+				newIsRegisteredOnRoot = c.addHandler(each, newServeMux)
+			}
+			newServices = append(newServices, each)
+		}
+	}
+	c.webServices, c.ServeMux, c.isRegisteredOnRoot = newServices, newServeMux, newIsRegisteredOnRoot
+	return nil
+}
+
+// logStackOnRecover is the default RecoverHandleFunction and is called
+// when DoNotRecover is false and the recoverHandleFunc is not set for the container.
+// Default implementation logs the stacktrace and writes the stacktrace on the response.
+// This may be a security issue as it exposes sourcecode information.
+func logStackOnRecover(panicReason interface{}, httpWriter http.ResponseWriter) {
+	var buffer bytes.Buffer
+	buffer.WriteString(fmt.Sprintf("[restful] recover from panic situation: - %v\r\n", panicReason))
+	for i := 2; ; i += 1 {
+		_, file, line, ok := runtime.Caller(i)
+		if !ok {
+			break
+		}
+		buffer.WriteString(fmt.Sprintf("    %s:%d\r\n", file, line))
+	}
+	log.Print(buffer.String())
+	httpWriter.WriteHeader(http.StatusInternalServerError)
+	httpWriter.Write(buffer.Bytes())
+}
+
+// writeServiceError is the default ServiceErrorHandleFunction and is called
+// when a ServiceError is returned during route selection. Default implementation
+// calls resp.WriteErrorString(err.Code, err.Message)
+func writeServiceError(err ServiceError, req *Request, resp *Response) {
+	resp.WriteErrorString(err.Code, err.Message)
+}
+
+// Dispatch the incoming Http Request to a matching WebService.
+func (c *Container) Dispatch(httpWriter http.ResponseWriter, httpRequest *http.Request) {
+	if httpWriter == nil {
+		panic("httpWriter cannot be nil")
+	}
+	if httpRequest == nil {
+		panic("httpRequest cannot be nil")
+	}
+	c.dispatch(httpWriter, httpRequest)
+}
+
+// Dispatch the incoming Http Request to a matching WebService.
+func (c *Container) dispatch(httpWriter http.ResponseWriter, httpRequest *http.Request) {
+	writer := httpWriter
+
+	// CompressingResponseWriter should be closed after all operations are done
+	defer func() {
+		if compressWriter, ok := writer.(*CompressingResponseWriter); ok {
+			compressWriter.Close()
+		}
+	}()
+
+	// Instal panic recovery unless told otherwise
+	if !c.doNotRecover { // catch all for 500 response
+		defer func() {
+			if r := recover(); r != nil {
+				c.recoverHandleFunc(r, writer)
+				return
+			}
+		}()
+	}
+
+	// Detect if compression is needed
+	// assume without compression, test for override
+	if c.contentEncodingEnabled {
+		doCompress, encoding := wantsCompressedResponse(httpRequest)
+		if doCompress {
+			var err error
+			writer, err = NewCompressingResponseWriter(httpWriter, encoding)
+			if err != nil {
+				log.Print("[restful] unable to install compressor: ", err)
+				httpWriter.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+		}
+	}
+	// Find best match Route ; err is non nil if no match was found
+	var webService *WebService
+	var route *Route
+	var err error
+	func() {
+		c.webServicesLock.RLock()
+		defer c.webServicesLock.RUnlock()
+		webService, route, err = c.router.SelectRoute(
+			c.webServices,
+			httpRequest)
+	}()
+	if err != nil {
+		// a non-200 response has already been written
+		// run container filters anyway ; they should not touch the response...
+		chain := FilterChain{Filters: c.containerFilters, Target: func(req *Request, resp *Response) {
+			switch err.(type) {
+			case ServiceError:
+				ser := err.(ServiceError)
+				c.serviceErrorHandleFunc(ser, req, resp)
+			}
+			// TODO
+		}}
+		chain.ProcessFilter(NewRequest(httpRequest), NewResponse(writer))
+		return
+	}
+	wrappedRequest, wrappedResponse := route.wrapRequestResponse(writer, httpRequest)
+	// pass through filters (if any)
+	if len(c.containerFilters)+len(webService.filters)+len(route.Filters) > 0 {
+		// compose filter chain
+		allFilters := []FilterFunction{}
+		allFilters = append(allFilters, c.containerFilters...)
+		allFilters = append(allFilters, webService.filters...)
+		allFilters = append(allFilters, route.Filters...)
+		chain := FilterChain{Filters: allFilters, Target: func(req *Request, resp *Response) {
+			// handle request by route after passing all filters
+			route.Function(wrappedRequest, wrappedResponse)
+		}}
+		chain.ProcessFilter(wrappedRequest, wrappedResponse)
+	} else {
+		// no filters, handle request by route
+		route.Function(wrappedRequest, wrappedResponse)
+	}
+}
+
+// fixedPrefixPath returns the fixed part of the partspec ; it may include template vars {}
+func fixedPrefixPath(pathspec string) string {
+	varBegin := strings.Index(pathspec, "{")
+	if -1 == varBegin {
+		return pathspec
+	}
+	return pathspec[:varBegin]
+}
+
+// ServeHTTP implements net/http.Handler therefore a Container can be a Handler in a http.Server
+func (c *Container) ServeHTTP(httpwriter http.ResponseWriter, httpRequest *http.Request) {
+	c.ServeMux.ServeHTTP(httpwriter, httpRequest)
+}
+
+// Handle registers the handler for the given pattern. If a handler already exists for pattern, Handle panics.
+func (c *Container) Handle(pattern string, handler http.Handler) {
+	c.ServeMux.Handle(pattern, handler)
+}
+
+// HandleWithFilter registers the handler for the given pattern.
+// Container's filter chain is applied for handler.
+// If a handler already exists for pattern, HandleWithFilter panics.
+func (c *Container) HandleWithFilter(pattern string, handler http.Handler) {
+	f := func(httpResponse http.ResponseWriter, httpRequest *http.Request) {
+		if len(c.containerFilters) == 0 {
+			handler.ServeHTTP(httpResponse, httpRequest)
+			return
+		}
+
+		chain := FilterChain{Filters: c.containerFilters, Target: func(req *Request, resp *Response) {
+			handler.ServeHTTP(httpResponse, httpRequest)
+		}}
+		chain.ProcessFilter(NewRequest(httpRequest), NewResponse(httpResponse))
+	}
+
+	c.Handle(pattern, http.HandlerFunc(f))
+}
+
+// Filter appends a container FilterFunction. These are called before dispatching
+// a http.Request to a WebService from the container
+func (c *Container) Filter(filter FilterFunction) {
+	c.containerFilters = append(c.containerFilters, filter)
+}
+
+// RegisteredWebServices returns the collections of added WebServices
+func (c *Container) RegisteredWebServices() []*WebService {
+	c.webServicesLock.RLock()
+	defer c.webServicesLock.RUnlock()
+	result := make([]*WebService, len(c.webServices))
+	for ix := range c.webServices {
+		result[ix] = c.webServices[ix]
+	}
+	return result
+}
+
+// computeAllowedMethods returns a list of HTTP methods that are valid for a Request
+func (c *Container) computeAllowedMethods(req *Request) []string {
+	// Go through all RegisteredWebServices() and all its Routes to collect the options
+	methods := []string{}
+	requestPath := req.Request.URL.Path
+	for _, ws := range c.RegisteredWebServices() {
+		matches := ws.pathExpr.Matcher.FindStringSubmatch(requestPath)
+		if matches != nil {
+			finalMatch := matches[len(matches)-1]
+			for _, rt := range ws.Routes() {
+				matches := rt.pathExpr.Matcher.FindStringSubmatch(finalMatch)
+				if matches != nil {
+					lastMatch := matches[len(matches)-1]
+					if lastMatch == "" || lastMatch == "/" { // do not include if value is neither empty nor ‘/’.
+						methods = append(methods, rt.Method)
+					}
+				}
+			}
+		}
+	}
+	// methods = append(methods, "OPTIONS")  not sure about this
+	return methods
+}
+
+// newBasicRequestResponse creates a pair of Request,Response from its http versions.
+// It is basic because no parameter or (produces) content-type information is given.
+func newBasicRequestResponse(httpWriter http.ResponseWriter, httpRequest *http.Request) (*Request, *Response) {
+	resp := NewResponse(httpWriter)
+	resp.requestAccept = httpRequest.Header.Get(HEADER_Accept)
+	return NewRequest(httpRequest), resp
+}
--- a/vendor/github.com/emicklei/go-restful/container_test.go
+++ b/vendor/github.com/emicklei/go-restful/container_test.go
@ -0,0 +1,83 @@
+package restful
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// go test -v -test.run TestContainer_computeAllowedMethods ...restful
+func TestContainer_computeAllowedMethods(t *testing.T) {
+	wc := NewContainer()
+	ws1 := new(WebService).Path("/users")
+	ws1.Route(ws1.GET("{i}").To(dummy))
+	ws1.Route(ws1.POST("{i}").To(dummy))
+	wc.Add(ws1)
+	httpRequest, _ := http.NewRequest("GET", "http://api.his.com/users/1", nil)
+	rreq := Request{Request: httpRequest}
+	m := wc.computeAllowedMethods(&rreq)
+	if len(m) != 2 {
+		t.Errorf("got %d expected 2 methods, %v", len(m), m)
+	}
+}
+
+func TestContainer_HandleWithFilter(t *testing.T) {
+	prefilterCalled := false
+	postfilterCalled := false
+	httpHandlerCalled := false
+
+	wc := NewContainer()
+	wc.Filter(func(request *Request, response *Response, chain *FilterChain) {
+		prefilterCalled = true
+		chain.ProcessFilter(request, response)
+	})
+	wc.HandleWithFilter("/", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		httpHandlerCalled = true
+		w.Write([]byte("ok"))
+	}))
+	wc.Filter(func(request *Request, response *Response, chain *FilterChain) {
+		postfilterCalled = true
+		chain.ProcessFilter(request, response)
+	})
+
+	recorder := httptest.NewRecorder()
+	request, _ := http.NewRequest("GET", "/", nil)
+	wc.ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusOK {
+		t.Errorf("unexpected code %d", recorder.Code)
+	}
+	if recorder.Body.String() != "ok" {
+		t.Errorf("unexpected body %s", recorder.Body.String())
+	}
+	if !prefilterCalled {
+		t.Errorf("filter added before calling HandleWithFilter wasn't called")
+	}
+	if !postfilterCalled {
+		t.Errorf("filter added after calling HandleWithFilter wasn't called")
+	}
+	if !httpHandlerCalled {
+		t.Errorf("handler added by calling HandleWithFilter wasn't called")
+	}
+}
+
+func TestContainerAddAndRemove(t *testing.T) {
+	ws1 := new(WebService).Path("/")
+	ws2 := new(WebService).Path("/users")
+	wc := NewContainer()
+	wc.Add(ws1)
+	wc.Add(ws2)
+	wc.Remove(ws2)
+	if len(wc.webServices) != 1 {
+		t.Errorf("expected one webservices")
+	}
+	if !wc.isRegisteredOnRoot {
+		t.Errorf("expected on root registered")
+	}
+	wc.Remove(ws1)
+	if len(wc.webServices) > 0 {
+		t.Errorf("expected zero webservices")
+	}
+	if wc.isRegisteredOnRoot {
+		t.Errorf("expected not on root registered")
+	}
+}
--- a/vendor/github.com/emicklei/go-restful/cors_filter.go
+++ b/vendor/github.com/emicklei/go-restful/cors_filter.go
@ -0,0 +1,202 @@
+package restful
+
+// Copyright 2013 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// CrossOriginResourceSharing is used to create a Container Filter that implements CORS.
+// Cross-origin resource sharing (CORS) is a mechanism that allows JavaScript on a web page
+// to make XMLHttpRequests to another domain, not the domain the JavaScript originated from.
+//
+// http://en.wikipedia.org/wiki/Cross-origin_resource_sharing
+// http://enable-cors.org/server.html
+// http://www.html5rocks.com/en/tutorials/cors/#toc-handling-a-not-so-simple-request
+type CrossOriginResourceSharing struct {
+	ExposeHeaders  []string // list of Header names
+	AllowedHeaders []string // list of Header names
+	AllowedDomains []string // list of allowed values for Http Origin. An allowed value can be a regular expression to support subdomain matching. If empty all are allowed.
+	AllowedMethods []string
+	MaxAge         int // number of seconds before requiring new Options request
+	CookiesAllowed bool
+	Container      *Container
+
+	allowedOriginPatterns []*regexp.Regexp // internal field for origin regexp check.
+}
+
+// Filter is a filter function that implements the CORS flow as documented on http://enable-cors.org/server.html
+// and http://www.html5rocks.com/static/images/cors_server_flowchart.png
+func (c CrossOriginResourceSharing) Filter(req *Request, resp *Response, chain *FilterChain) {
+	origin := req.Request.Header.Get(HEADER_Origin)
+	if len(origin) == 0 {
+		if trace {
+			traceLogger.Print("no Http header Origin set")
+		}
+		chain.ProcessFilter(req, resp)
+		return
+	}
+	if !c.isOriginAllowed(origin) { // check whether this origin is allowed
+		if trace {
+			traceLogger.Printf("HTTP Origin:%s is not part of %v, neither matches any part of %v", origin, c.AllowedDomains, c.allowedOriginPatterns)
+		}
+		chain.ProcessFilter(req, resp)
+		return
+	}
+	if req.Request.Method != "OPTIONS" {
+		c.doActualRequest(req, resp)
+		chain.ProcessFilter(req, resp)
+		return
+	}
+	if acrm := req.Request.Header.Get(HEADER_AccessControlRequestMethod); acrm != "" {
+		c.doPreflightRequest(req, resp)
+	} else {
+		c.doActualRequest(req, resp)
+		chain.ProcessFilter(req, resp)
+		return
+	}
+}
+
+func (c CrossOriginResourceSharing) doActualRequest(req *Request, resp *Response) {
+	c.setOptionsHeaders(req, resp)
+	// continue processing the response
+}
+
+func (c *CrossOriginResourceSharing) doPreflightRequest(req *Request, resp *Response) {
+	if len(c.AllowedMethods) == 0 {
+		if c.Container == nil {
+			c.AllowedMethods = DefaultContainer.computeAllowedMethods(req)
+		} else {
+			c.AllowedMethods = c.Container.computeAllowedMethods(req)
+		}
+	}
+
+	acrm := req.Request.Header.Get(HEADER_AccessControlRequestMethod)
+	if !c.isValidAccessControlRequestMethod(acrm, c.AllowedMethods) {
+		if trace {
+			traceLogger.Printf("Http header %s:%s is not in %v",
+				HEADER_AccessControlRequestMethod,
+				acrm,
+				c.AllowedMethods)
+		}
+		return
+	}
+	acrhs := req.Request.Header.Get(HEADER_AccessControlRequestHeaders)
+	if len(acrhs) > 0 {
+		for _, each := range strings.Split(acrhs, ",") {
+			if !c.isValidAccessControlRequestHeader(strings.Trim(each, " ")) {
+				if trace {
+					traceLogger.Printf("Http header %s:%s is not in %v",
+						HEADER_AccessControlRequestHeaders,
+						acrhs,
+						c.AllowedHeaders)
+				}
+				return
+			}
+		}
+	}
+	resp.AddHeader(HEADER_AccessControlAllowMethods, strings.Join(c.AllowedMethods, ","))
+	resp.AddHeader(HEADER_AccessControlAllowHeaders, acrhs)
+	c.setOptionsHeaders(req, resp)
+
+	// return http 200 response, no body
+}
+
+func (c CrossOriginResourceSharing) setOptionsHeaders(req *Request, resp *Response) {
+	c.checkAndSetExposeHeaders(resp)
+	c.setAllowOriginHeader(req, resp)
+	c.checkAndSetAllowCredentials(resp)
+	if c.MaxAge > 0 {
+		resp.AddHeader(HEADER_AccessControlMaxAge, strconv.Itoa(c.MaxAge))
+	}
+}
+
+func (c CrossOriginResourceSharing) isOriginAllowed(origin string) bool {
+	if len(origin) == 0 {
+		return false
+	}
+	if len(c.AllowedDomains) == 0 {
+		return true
+	}
+
+	allowed := false
+	for _, domain := range c.AllowedDomains {
+		if domain == origin {
+			allowed = true
+			break
+		}
+	}
+
+	if !allowed {
+		if len(c.allowedOriginPatterns) == 0 {
+			// compile allowed domains to allowed origin patterns
+			allowedOriginRegexps, err := compileRegexps(c.AllowedDomains)
+			if err != nil {
+				return false
+			}
+			c.allowedOriginPatterns = allowedOriginRegexps
+		}
+
+		for _, pattern := range c.allowedOriginPatterns {
+			if allowed = pattern.MatchString(origin); allowed {
+				break
+			}
+		}
+	}
+
+	return allowed
+}
+
+func (c CrossOriginResourceSharing) setAllowOriginHeader(req *Request, resp *Response) {
+	origin := req.Request.Header.Get(HEADER_Origin)
+	if c.isOriginAllowed(origin) {
+		resp.AddHeader(HEADER_AccessControlAllowOrigin, origin)
+	}
+}
+
+func (c CrossOriginResourceSharing) checkAndSetExposeHeaders(resp *Response) {
+	if len(c.ExposeHeaders) > 0 {
+		resp.AddHeader(HEADER_AccessControlExposeHeaders, strings.Join(c.ExposeHeaders, ","))
+	}
+}
+
+func (c CrossOriginResourceSharing) checkAndSetAllowCredentials(resp *Response) {
+	if c.CookiesAllowed {
+		resp.AddHeader(HEADER_AccessControlAllowCredentials, "true")
+	}
+}
+
+func (c CrossOriginResourceSharing) isValidAccessControlRequestMethod(method string, allowedMethods []string) bool {
+	for _, each := range allowedMethods {
+		if each == method {
+			return true
+		}
+	}
+	return false
+}
+
+func (c CrossOriginResourceSharing) isValidAccessControlRequestHeader(header string) bool {
+	for _, each := range c.AllowedHeaders {
+		if strings.ToLower(each) == strings.ToLower(header) {
+			return true
+		}
+	}
+	return false
+}
+
+// Take a list of strings and compile them into a list of regular expressions.
+func compileRegexps(regexpStrings []string) ([]*regexp.Regexp, error) {
+	regexps := []*regexp.Regexp{}
+	for _, regexpStr := range regexpStrings {
+		r, err := regexp.Compile(regexpStr)
+		if err != nil {
+			return regexps, err
+		}
+		regexps = append(regexps, r)
+	}
+	return regexps, nil
+}
--- a/vendor/github.com/emicklei/go-restful/cors_filter_test.go
+++ b/vendor/github.com/emicklei/go-restful/cors_filter_test.go
@ -0,0 +1,129 @@
+package restful
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// go test -v -test.run TestCORSFilter_Preflight ...restful
+// http://www.html5rocks.com/en/tutorials/cors/#toc-handling-a-not-so-simple-request
+func TestCORSFilter_Preflight(t *testing.T) {
+	tearDown()
+	ws := new(WebService)
+	ws.Route(ws.PUT("/cors").To(dummy))
+	Add(ws)
+
+	cors := CrossOriginResourceSharing{
+		ExposeHeaders:  []string{"X-Custom-Header"},
+		AllowedHeaders: []string{"X-Custom-Header", "X-Additional-Header"},
+		CookiesAllowed: true,
+		Container:      DefaultContainer}
+	Filter(cors.Filter)
+
+	// Preflight
+	httpRequest, _ := http.NewRequest("OPTIONS", "http://api.alice.com/cors", nil)
+	httpRequest.Method = "OPTIONS"
+	httpRequest.Header.Set(HEADER_Origin, "http://api.bob.com")
+	httpRequest.Header.Set(HEADER_AccessControlRequestMethod, "PUT")
+	httpRequest.Header.Set(HEADER_AccessControlRequestHeaders, "X-Custom-Header, X-Additional-Header")
+
+	httpWriter := httptest.NewRecorder()
+	DefaultContainer.Dispatch(httpWriter, httpRequest)
+
+	actual := httpWriter.Header().Get(HEADER_AccessControlAllowOrigin)
+	if "http://api.bob.com" != actual {
+		t.Fatal("expected: http://api.bob.com but got:" + actual)
+	}
+	actual = httpWriter.Header().Get(HEADER_AccessControlAllowMethods)
+	if "PUT" != actual {
+		t.Fatal("expected: PUT but got:" + actual)
+	}
+	actual = httpWriter.Header().Get(HEADER_AccessControlAllowHeaders)
+	if "X-Custom-Header, X-Additional-Header" != actual {
+		t.Fatal("expected: X-Custom-Header, X-Additional-Header but got:" + actual)
+	}
+
+	if !cors.isOriginAllowed("somewhere") {
+		t.Fatal("origin expected to be allowed")
+	}
+	cors.AllowedDomains = []string{"overthere.com"}
+	if cors.isOriginAllowed("somewhere") {
+		t.Fatal("origin [somewhere] expected NOT to be allowed")
+	}
+	if !cors.isOriginAllowed("overthere.com") {
+		t.Fatal("origin [overthere] expected to be allowed")
+	}
+
+}
+
+// go test -v -test.run TestCORSFilter_Actual ...restful
+// http://www.html5rocks.com/en/tutorials/cors/#toc-handling-a-not-so-simple-request
+func TestCORSFilter_Actual(t *testing.T) {
+	tearDown()
+	ws := new(WebService)
+	ws.Route(ws.PUT("/cors").To(dummy))
+	Add(ws)
+
+	cors := CrossOriginResourceSharing{
+		ExposeHeaders:  []string{"X-Custom-Header"},
+		AllowedHeaders: []string{"X-Custom-Header", "X-Additional-Header"},
+		CookiesAllowed: true,
+		Container:      DefaultContainer}
+	Filter(cors.Filter)
+
+	// Actual
+	httpRequest, _ := http.NewRequest("PUT", "http://api.alice.com/cors", nil)
+	httpRequest.Header.Set(HEADER_Origin, "http://api.bob.com")
+	httpRequest.Header.Set("X-Custom-Header", "value")
+
+	httpWriter := httptest.NewRecorder()
+	DefaultContainer.Dispatch(httpWriter, httpRequest)
+	actual := httpWriter.Header().Get(HEADER_AccessControlAllowOrigin)
+	if "http://api.bob.com" != actual {
+		t.Fatal("expected: http://api.bob.com but got:" + actual)
+	}
+	if httpWriter.Body.String() != "dummy" {
+		t.Fatal("expected: dummy but got:" + httpWriter.Body.String())
+	}
+}
+
+var allowedDomainInput = []struct {
+	domains []string
+	origin  string
+	allowed bool
+}{
+	{[]string{}, "http://anything.com", true},
+	{[]string{"example.com"}, "example.com", true},
+	{[]string{"example.com"}, "not-allowed", false},
+	{[]string{"not-matching.com", "example.com"}, "example.com", true},
+	{[]string{".*"}, "example.com", true},
+}
+
+// go test -v -test.run TestCORSFilter_AllowedDomains ...restful
+func TestCORSFilter_AllowedDomains(t *testing.T) {
+	for _, each := range allowedDomainInput {
+		tearDown()
+		ws := new(WebService)
+		ws.Route(ws.PUT("/cors").To(dummy))
+		Add(ws)
+
+		cors := CrossOriginResourceSharing{
+			AllowedDomains: each.domains,
+			CookiesAllowed: true,
+			Container:      DefaultContainer}
+		Filter(cors.Filter)
+
+		httpRequest, _ := http.NewRequest("PUT", "http://api.his.com/cors", nil)
+		httpRequest.Header.Set(HEADER_Origin, each.origin)
+		httpWriter := httptest.NewRecorder()
+		DefaultContainer.Dispatch(httpWriter, httpRequest)
+		actual := httpWriter.Header().Get(HEADER_AccessControlAllowOrigin)
+		if actual != each.origin && each.allowed {
+			t.Fatal("expected to be accepted")
+		}
+		if actual == each.origin && !each.allowed {
+			t.Fatal("did not expect to be accepted")
+		}
+	}
+}
--- a/vendor/github.com/emicklei/go-restful/coverage.sh
+++ b/vendor/github.com/emicklei/go-restful/coverage.sh
@ -0,0 +1,2 @@
+go test -coverprofile=coverage.out
+go tool cover -html=coverage.out
--- a/vendor/github.com/emicklei/go-restful/curly.go
+++ b/vendor/github.com/emicklei/go-restful/curly.go
@ -0,0 +1,164 @@
+package restful
+
+// Copyright 2013 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+import (
+	"net/http"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+// CurlyRouter expects Routes with paths that contain zero or more parameters in curly brackets.
+type CurlyRouter struct{}
+
+// SelectRoute is part of the Router interface and returns the best match
+// for the WebService and its Route for the given Request.
+func (c CurlyRouter) SelectRoute(
+	webServices []*WebService,
+	httpRequest *http.Request) (selectedService *WebService, selected *Route, err error) {
+
+	requestTokens := tokenizePath(httpRequest.URL.Path)
+
+	detectedService := c.detectWebService(requestTokens, webServices)
+	if detectedService == nil {
+		if trace {
+			traceLogger.Printf("no WebService was found to match URL path:%s\n", httpRequest.URL.Path)
+		}
+		return nil, nil, NewError(http.StatusNotFound, "404: Page Not Found")
+	}
+	candidateRoutes := c.selectRoutes(detectedService, requestTokens)
+	if len(candidateRoutes) == 0 {
+		if trace {
+			traceLogger.Printf("no Route in WebService with path %s was found to match URL path:%s\n", detectedService.rootPath, httpRequest.URL.Path)
+		}
+		return detectedService, nil, NewError(http.StatusNotFound, "404: Page Not Found")
+	}
+	selectedRoute, err := c.detectRoute(candidateRoutes, httpRequest)
+	if selectedRoute == nil {
+		return detectedService, nil, err
+	}
+	return detectedService, selectedRoute, nil
+}
+
+// selectRoutes return a collection of Route from a WebService that matches the path tokens from the request.
+func (c CurlyRouter) selectRoutes(ws *WebService, requestTokens []string) sortableCurlyRoutes {
+	candidates := sortableCurlyRoutes{}
+	for _, each := range ws.routes {
+		matches, paramCount, staticCount := c.matchesRouteByPathTokens(each.pathParts, requestTokens)
+		if matches {
+			candidates.add(curlyRoute{each, paramCount, staticCount}) // TODO make sure Routes() return pointers?
+		}
+	}
+	sort.Sort(sort.Reverse(candidates))
+	return candidates
+}
+
+// matchesRouteByPathTokens computes whether it matches, howmany parameters do match and what the number of static path elements are.
+func (c CurlyRouter) matchesRouteByPathTokens(routeTokens, requestTokens []string) (matches bool, paramCount int, staticCount int) {
+	if len(routeTokens) < len(requestTokens) {
+		// proceed in matching only if last routeToken is wildcard
+		count := len(routeTokens)
+		if count == 0 || !strings.HasSuffix(routeTokens[count-1], "*}") {
+			return false, 0, 0
+		}
+		// proceed
+	}
+	for i, routeToken := range routeTokens {
+		if i == len(requestTokens) {
+			// reached end of request path
+			return false, 0, 0
+		}
+		requestToken := requestTokens[i]
+		if strings.HasPrefix(routeToken, "{") {
+			paramCount++
+			if colon := strings.Index(routeToken, ":"); colon != -1 {
+				// match by regex
+				matchesToken, matchesRemainder := c.regularMatchesPathToken(routeToken, colon, requestToken)
+				if !matchesToken {
+					return false, 0, 0
+				}
+				if matchesRemainder {
+					break
+				}
+			}
+		} else { // no { prefix
+			if requestToken != routeToken {
+				return false, 0, 0
+			}
+			staticCount++
+		}
+	}
+	return true, paramCount, staticCount
+}
+
+// regularMatchesPathToken tests whether the regular expression part of routeToken matches the requestToken or all remaining tokens
+// format routeToken is {someVar:someExpression}, e.g. {zipcode:[\d][\d][\d][\d][A-Z][A-Z]}
+func (c CurlyRouter) regularMatchesPathToken(routeToken string, colon int, requestToken string) (matchesToken bool, matchesRemainder bool) {
+	regPart := routeToken[colon+1 : len(routeToken)-1]
+	if regPart == "*" {
+		if trace {
+			traceLogger.Printf("wildcard parameter detected in route token %s that matches %s\n", routeToken, requestToken)
+		}
+		return true, true
+	}
+	matched, err := regexp.MatchString(regPart, requestToken)
+	return (matched && err == nil), false
+}
+
+var jsr311Router = RouterJSR311{}
+
+// detectRoute selectes from a list of Route the first match by inspecting both the Accept and Content-Type
+// headers of the Request. See also RouterJSR311 in jsr311.go
+func (c CurlyRouter) detectRoute(candidateRoutes sortableCurlyRoutes, httpRequest *http.Request) (*Route, error) {
+	// tracing is done inside detectRoute
+	return jsr311Router.detectRoute(candidateRoutes.routes(), httpRequest)
+}
+
+// detectWebService returns the best matching webService given the list of path tokens.
+// see also computeWebserviceScore
+func (c CurlyRouter) detectWebService(requestTokens []string, webServices []*WebService) *WebService {
+	var best *WebService
+	score := -1
+	for _, each := range webServices {
+		matches, eachScore := c.computeWebserviceScore(requestTokens, each.pathExpr.tokens)
+		if matches && (eachScore > score) {
+			best = each
+			score = eachScore
+		}
+	}
+	return best
+}
+
+// computeWebserviceScore returns whether tokens match and
+// the weighted score of the longest matching consecutive tokens from the beginning.
+func (c CurlyRouter) computeWebserviceScore(requestTokens []string, tokens []string) (bool, int) {
+	if len(tokens) > len(requestTokens) {
+		return false, 0
+	}
+	score := 0
+	for i := 0; i < len(tokens); i++ {
+		each := requestTokens[i]
+		other := tokens[i]
+		if len(each) == 0 && len(other) == 0 {
+			score++
+			continue
+		}
+		if len(other) > 0 && strings.HasPrefix(other, "{") {
+			// no empty match
+			if len(each) == 0 {
+				return false, score
+			}
+			score += 1
+		} else {
+			// not a parameter
+			if each != other {
+				return false, score
+			}
+			score += (len(tokens) - i) * 10 //fuzzy
+		}
+	}
+	return true, score
+}
--- a/vendor/github.com/emicklei/go-restful/curly_route.go
+++ b/vendor/github.com/emicklei/go-restful/curly_route.go
@ -0,0 +1,52 @@
+package restful
+
+// Copyright 2013 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+// curlyRoute exits for sorting Routes by the CurlyRouter based on number of parameters and number of static path elements.
+type curlyRoute struct {
+	route       Route
+	paramCount  int
+	staticCount int
+}
+
+type sortableCurlyRoutes []curlyRoute
+
+func (s *sortableCurlyRoutes) add(route curlyRoute) {
+	*s = append(*s, route)
+}
+
+func (s sortableCurlyRoutes) routes() (routes []Route) {
+	for _, each := range s {
+		routes = append(routes, each.route) // TODO change return type
+	}
+	return routes
+}
+
+func (s sortableCurlyRoutes) Len() int {
+	return len(s)
+}
+func (s sortableCurlyRoutes) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+func (s sortableCurlyRoutes) Less(i, j int) bool {
+	ci := s[i]
+	cj := s[j]
+
+	// primary key
+	if ci.staticCount < cj.staticCount {
+		return true
+	}
+	if ci.staticCount > cj.staticCount {
+		return false
+	}
+	// secundary key
+	if ci.paramCount < cj.paramCount {
+		return true
+	}
+	if ci.paramCount > cj.paramCount {
+		return false
+	}
+	return ci.route.Path < cj.route.Path
+}
--- a/vendor/github.com/emicklei/go-restful/curly_test.go
+++ b/vendor/github.com/emicklei/go-restful/curly_test.go
@ -0,0 +1,231 @@
+package restful
+
+import (
+	"io"
+	"net/http"
+	"testing"
+)
+
+var requestPaths = []struct {
+	// url with path (1) is handled by service with root (2) and remainder has value final (3)
+	path, root string
+}{
+	{"/", "/"},
+	{"/p", "/p"},
+	{"/p/x", "/p/{q}"},
+	{"/q/x", "/q"},
+	{"/p/x/", "/p/{q}"},
+	{"/p/x/y", "/p/{q}"},
+	{"/q/x/y", "/q"},
+	{"/z/q", "/{p}/q"},
+	{"/a/b/c/q", "/"},
+}
+
+// go test -v -test.run TestCurlyDetectWebService ...restful
+func TestCurlyDetectWebService(t *testing.T) {
+	ws1 := new(WebService).Path("/")
+	ws2 := new(WebService).Path("/p")
+	ws3 := new(WebService).Path("/q")
+	ws4 := new(WebService).Path("/p/q")
+	ws5 := new(WebService).Path("/p/{q}")
+	ws7 := new(WebService).Path("/{p}/q")
+	var wss = []*WebService{ws1, ws2, ws3, ws4, ws5, ws7}
+
+	for _, each := range wss {
+		t.Logf("path=%s,toks=%v\n", each.pathExpr.Source, each.pathExpr.tokens)
+	}
+
+	router := CurlyRouter{}
+
+	ok := true
+	for i, fixture := range requestPaths {
+		requestTokens := tokenizePath(fixture.path)
+		who := router.detectWebService(requestTokens, wss)
+		if who != nil && who.RootPath() != fixture.root {
+			t.Logf("[line:%v] Unexpected dispatcher, expected:%v, actual:%v", i, fixture.root, who.RootPath())
+			ok = false
+		}
+	}
+	if !ok {
+		t.Fail()
+	}
+}
+
+var serviceDetects = []struct {
+	path  string
+	found bool
+	root  string
+}{
+	{"/a/b", true, "/{p}/{q}/{r}"},
+	{"/p/q", true, "/p/q"},
+	{"/q/p", true, "/q"},
+	{"/", true, "/"},
+	{"/p/q/r", true, "/p/q"},
+}
+
+// go test -v -test.run Test_detectWebService ...restful
+func Test_detectWebService(t *testing.T) {
+	router := CurlyRouter{}
+	ws1 := new(WebService).Path("/")
+	ws2 := new(WebService).Path("/p")
+	ws3 := new(WebService).Path("/q")
+	ws4 := new(WebService).Path("/p/q")
+	ws5 := new(WebService).Path("/p/{q}")
+	ws6 := new(WebService).Path("/p/{q}/")
+	ws7 := new(WebService).Path("/{p}/q")
+	ws8 := new(WebService).Path("/{p}/{q}/{r}")
+	var wss = []*WebService{ws8, ws7, ws6, ws5, ws4, ws3, ws2, ws1}
+	for _, fix := range serviceDetects {
+		requestPath := fix.path
+		requestTokens := tokenizePath(requestPath)
+		for _, ws := range wss {
+			serviceTokens := ws.pathExpr.tokens
+			matches, score := router.computeWebserviceScore(requestTokens, serviceTokens)
+			t.Logf("req=%s,toks:%v,ws=%s,toks:%v,score=%d,matches=%v", requestPath, requestTokens, ws.RootPath(), serviceTokens, score, matches)
+		}
+		best := router.detectWebService(requestTokens, wss)
+		if best != nil {
+			if fix.found {
+				t.Logf("best=%s", best.RootPath())
+			} else {
+				t.Fatalf("should have found:%s", fix.root)
+			}
+		}
+	}
+}
+
+var routeMatchers = []struct {
+	route       string
+	path        string
+	matches     bool
+	paramCount  int
+	staticCount int
+}{
+	// route, request-path
+	{"/a", "/a", true, 0, 1},
+	{"/a", "/b", false, 0, 0},
+	{"/a", "/b", false, 0, 0},
+	{"/a/{b}/c/", "/a/2/c", true, 1, 2},
+	{"/{a}/{b}/{c}/", "/a/b", false, 0, 0},
+	{"/{x:*}", "/", false, 0, 0},
+	{"/{x:*}", "/a", true, 1, 0},
+	{"/{x:*}", "/a/b", true, 1, 0},
+	{"/a/{x:*}", "/a/b", true, 1, 1},
+	{"/a/{x:[A-Z][A-Z]}", "/a/ZX", true, 1, 1},
+	{"/basepath/{resource:*}", "/basepath/some/other/location/test.xml", true, 1, 1},
+}
+
+// clear && go test -v -test.run Test_matchesRouteByPathTokens ...restful
+func Test_matchesRouteByPathTokens(t *testing.T) {
+	router := CurlyRouter{}
+	for i, each := range routeMatchers {
+		routeToks := tokenizePath(each.route)
+		reqToks := tokenizePath(each.path)
+		matches, pCount, sCount := router.matchesRouteByPathTokens(routeToks, reqToks)
+		if matches != each.matches {
+			t.Fatalf("[%d] unexpected matches outcome route:%s, path:%s, matches:%v", i, each.route, each.path, matches)
+		}
+		if pCount != each.paramCount {
+			t.Fatalf("[%d] unexpected paramCount got:%d want:%d ", i, pCount, each.paramCount)
+		}
+		if sCount != each.staticCount {
+			t.Fatalf("[%d] unexpected staticCount got:%d want:%d ", i, sCount, each.staticCount)
+		}
+	}
+}
+
+// clear && go test -v -test.run TestExtractParameters_Wildcard1 ...restful
+func TestExtractParameters_Wildcard1(t *testing.T) {
+	params := doExtractParams("/fixed/{var:*}", 2, "/fixed/remainder", t)
+	if params["var"] != "remainder" {
+		t.Errorf("parameter mismatch var: %s", params["var"])
+	}
+}
+
+// clear && go test -v -test.run TestExtractParameters_Wildcard2 ...restful
+func TestExtractParameters_Wildcard2(t *testing.T) {
+	params := doExtractParams("/fixed/{var:*}", 2, "/fixed/remain/der", t)
+	if params["var"] != "remain/der" {
+		t.Errorf("parameter mismatch var: %s", params["var"])
+	}
+}
+
+// clear && go test -v -test.run TestExtractParameters_Wildcard3 ...restful
+func TestExtractParameters_Wildcard3(t *testing.T) {
+	params := doExtractParams("/static/{var:*}", 2, "/static/test/sub/hi.html", t)
+	if params["var"] != "test/sub/hi.html" {
+		t.Errorf("parameter mismatch var: %s", params["var"])
+	}
+}
+
+// clear && go test -v -test.run TestCurly_ISSUE_34 ...restful
+func TestCurly_ISSUE_34(t *testing.T) {
+	ws1 := new(WebService).Path("/")
+	ws1.Route(ws1.GET("/{type}/{id}").To(curlyDummy))
+	ws1.Route(ws1.GET("/network/{id}").To(curlyDummy))
+	croutes := CurlyRouter{}.selectRoutes(ws1, tokenizePath("/network/12"))
+	if len(croutes) != 2 {
+		t.Fatal("expected 2 routes")
+	}
+	if got, want := croutes[0].route.Path, "/network/{id}"; got != want {
+		t.Errorf("got %v want %v", got, want)
+	}
+}
+
+// clear && go test -v -test.run TestCurly_ISSUE_34_2 ...restful
+func TestCurly_ISSUE_34_2(t *testing.T) {
+	ws1 := new(WebService)
+	ws1.Route(ws1.GET("/network/{id}").To(curlyDummy))
+	ws1.Route(ws1.GET("/{type}/{id}").To(curlyDummy))
+	croutes := CurlyRouter{}.selectRoutes(ws1, tokenizePath("/network/12"))
+	if len(croutes) != 2 {
+		t.Fatal("expected 2 routes")
+	}
+	if got, want := croutes[0].route.Path, "/network/{id}"; got != want {
+		t.Errorf("got %v want %v", got, want)
+	}
+}
+
+// clear && go test -v -test.run TestCurly_JsonHtml ...restful
+func TestCurly_JsonHtml(t *testing.T) {
+	ws1 := new(WebService)
+	ws1.Path("/")
+	ws1.Route(ws1.GET("/some.html").To(curlyDummy).Consumes("*/*").Produces("text/html"))
+	req, _ := http.NewRequest("GET", "/some.html", nil)
+	req.Header.Set("Accept", "application/json")
+	_, route, err := CurlyRouter{}.SelectRoute([]*WebService{ws1}, req)
+	if err == nil {
+		t.Error("error expected")
+	}
+	if route != nil {
+		t.Error("no route expected")
+	}
+}
+
+// go test -v -test.run TestCurly_ISSUE_137 ...restful
+func TestCurly_ISSUE_137(t *testing.T) {
+	ws1 := new(WebService)
+	ws1.Route(ws1.GET("/hello").To(curlyDummy))
+	ws1.Path("/")
+	req, _ := http.NewRequest("GET", "/", nil)
+	_, route, _ := CurlyRouter{}.SelectRoute([]*WebService{ws1}, req)
+	t.Log(route)
+	if route != nil {
+		t.Error("no route expected")
+	}
+}
+
+// go test -v -test.run TestCurly_ISSUE_137_2 ...restful
+func TestCurly_ISSUE_137_2(t *testing.T) {
+	ws1 := new(WebService)
+	ws1.Route(ws1.GET("/hello").To(curlyDummy))
+	ws1.Path("/")
+	req, _ := http.NewRequest("GET", "/hello/bob", nil)
+	_, route, _ := CurlyRouter{}.SelectRoute([]*WebService{ws1}, req)
+	t.Log(route)
+	if route != nil {
+		t.Errorf("no route expected, got %v", route)
+	}
+}
+
+func curlyDummy(req *Request, resp *Response) { io.WriteString(resp.ResponseWriter, "curlyDummy") }
--- a/vendor/github.com/emicklei/go-restful/doc.go
+++ b/vendor/github.com/emicklei/go-restful/doc.go
@ -0,0 +1,185 @@
+/*
+Package restful , a lean package for creating REST-style WebServices without magic.
+
+WebServices and Routes
+
+A WebService has a collection of Route objects that dispatch incoming Http Requests to a function calls.
+Typically, a WebService has a root path (e.g. /users) and defines common MIME types for its routes.
+WebServices must be added to a container (see below) in order to handler Http requests from a server.
+
+A Route is defined by a HTTP method, an URL path and (optionally) the MIME types it consumes (Content-Type) and produces (Accept).
+This package has the logic to find the best matching Route and if found, call its Function.
+
+	ws := new(restful.WebService)
+	ws.
+		Path("/users").
+		Consumes(restful.MIME_JSON, restful.MIME_XML).
+		Produces(restful.MIME_JSON, restful.MIME_XML)
+
+	ws.Route(ws.GET("/{user-id}").To(u.findUser))  // u is a UserResource
+
+	...
+
+	// GET http://localhost:8080/users/1
+	func (u UserResource) findUser(request *restful.Request, response *restful.Response) {
+		id := request.PathParameter("user-id")
+		...
+	}
+
+The (*Request, *Response) arguments provide functions for reading information from the request and writing information back to the response.
+
+See the example https://github.com/emicklei/go-restful/blob/master/examples/restful-user-resource.go with a full implementation.
+
+Regular expression matching Routes
+
+A Route parameter can be specified using the format "uri/{var[:regexp]}" or the special version "uri/{var:*}" for matching the tail of the path.
+For example, /persons/{name:[A-Z][A-Z]} can be used to restrict values for the parameter "name" to only contain capital alphabetic characters.
+Regular expressions must use the standard Go syntax as described in the regexp package. (https://code.google.com/p/re2/wiki/Syntax)
+This feature requires the use of a CurlyRouter.
+
+Containers
+
+A Container holds a collection of WebServices, Filters and a http.ServeMux for multiplexing http requests.
+Using the statements "restful.Add(...) and restful.Filter(...)" will register WebServices and Filters to the Default Container.
+The Default container of go-restful uses the http.DefaultServeMux.
+You can create your own Container and create a new http.Server for that particular container.
+
+	container := restful.NewContainer()
+	server := &http.Server{Addr: ":8081", Handler: container}
+
+Filters
+
+A filter dynamically intercepts requests and responses to transform or use the information contained in the requests or responses.
+You can use filters to perform generic logging, measurement, authentication, redirect, set response headers etc.
+In the restful package there are three hooks into the request,response flow where filters can be added.
+Each filter must define a FilterFunction:
+
+	func (req *restful.Request, resp *restful.Response, chain *restful.FilterChain)
+
+Use the following statement to pass the request,response pair to the next filter or RouteFunction
+
+	chain.ProcessFilter(req, resp)
+
+Container Filters
+
+These are processed before any registered WebService.
+
+	// install a (global) filter for the default container (processed before any webservice)
+	restful.Filter(globalLogging)
+
+WebService Filters
+
+These are processed before any Route of a WebService.
+
+	// install a webservice filter (processed before any route)
+	ws.Filter(webserviceLogging).Filter(measureTime)
+
+
+Route Filters
+
+These are processed before calling the function associated with the Route.
+
+	// install 2 chained route filters (processed before calling findUser)
+	ws.Route(ws.GET("/{user-id}").Filter(routeLogging).Filter(NewCountFilter().routeCounter).To(findUser))
+
+See the example https://github.com/emicklei/go-restful/blob/master/examples/restful-filters.go with full implementations.
+
+Response Encoding
+
+Two encodings are supported: gzip and deflate. To enable this for all responses:
+
+	restful.DefaultContainer.EnableContentEncoding(true)
+
+If a Http request includes the Accept-Encoding header then the response content will be compressed using the specified encoding.
+Alternatively, you can create a Filter that performs the encoding and install it per WebService or Route.
+
+See the example https://github.com/emicklei/go-restful/blob/master/examples/restful-encoding-filter.go
+
+OPTIONS support
+
+By installing a pre-defined container filter, your Webservice(s) can respond to the OPTIONS Http request.
+
+	Filter(OPTIONSFilter())
+
+CORS
+
+By installing the filter of a CrossOriginResourceSharing (CORS), your WebService(s) can handle CORS requests.
+
+	cors := CrossOriginResourceSharing{ExposeHeaders: []string{"X-My-Header"}, CookiesAllowed: false, Container: DefaultContainer}
+	Filter(cors.Filter)
+
+Error Handling
+
+Unexpected things happen. If a request cannot be processed because of a failure, your service needs to tell via the response what happened and why.
+For this reason HTTP status codes exist and it is important to use the correct code in every exceptional situation.
+
+	400: Bad Request
+
+If path or query parameters are not valid (content or type) then use http.StatusBadRequest.
+
+	404: Not Found
+
+Despite a valid URI, the resource requested may not be available
+
+	500: Internal Server Error
+
+If the application logic could not process the request (or write the response) then use http.StatusInternalServerError.
+
+	405: Method Not Allowed
+
+The request has a valid URL but the method (GET,PUT,POST,...) is not allowed.
+
+	406: Not Acceptable
+
+The request does not have or has an unknown Accept Header set for this operation.
+
+	415: Unsupported Media Type
+
+The request does not have or has an unknown Content-Type Header set for this operation.
+
+ServiceError
+
+In addition to setting the correct (error) Http status code, you can choose to write a ServiceError message on the response.
+
+Performance options
+
+This package has several options that affect the performance of your service. It is important to understand them and how you can change it.
+
+	restful.DefaultContainer.DoNotRecover(false)
+
+DoNotRecover controls whether panics will be caught to return HTTP 500.
+If set to false, the container will recover from panics.
+Default value is true
+
+	restful.SetCompressorProvider(NewBoundedCachedCompressors(20, 20))
+
+If content encoding is enabled then the default strategy for getting new gzip/zlib writers and readers is to use a sync.Pool.
+Because writers are expensive structures, performance is even more improved when using a preloaded cache. You can also inject your own implementation.
+
+Trouble shooting
+
+This package has the means to produce detail logging of the complete Http request matching process and filter invocation.
+Enabling this feature requires you to set an implementation of restful.StdLogger (e.g. log.Logger) instance such as:
+
+	restful.TraceLogger(log.New(os.Stdout, "[restful] ", log.LstdFlags|log.Lshortfile))
+
+Logging
+
+The restful.SetLogger() method allows you to override the logger used by the package. By default restful
+uses the standard library `log` package and logs to stdout. Different logging packages are supported as
+long as they conform to `StdLogger` interface defined in the `log` sub-package, writing an adapter for your
+preferred package is simple.
+
+Resources
+
+[project]: https://github.com/emicklei/go-restful
+
+[examples]: https://github.com/emicklei/go-restful/blob/master/examples
+
+[design]:  http://ernestmicklei.com/2012/11/11/go-restful-api-design/
+
+[showcases]: https://github.com/emicklei/mora, https://github.com/emicklei/landskape
+
+(c) 2012-2015, http://ernestmicklei.com. MIT License
+*/
+package restful
--- a/vendor/github.com/emicklei/go-restful/doc_examples_test.go
+++ b/vendor/github.com/emicklei/go-restful/doc_examples_test.go
@ -0,0 +1,41 @@
+package restful
+
+import "net/http"
+
+func ExampleOPTIONSFilter() {
+	// Install the OPTIONS filter on the default Container
+	Filter(OPTIONSFilter())
+}
+func ExampleContainer_OPTIONSFilter() {
+	// Install the OPTIONS filter on a Container
+	myContainer := new(Container)
+	myContainer.Filter(myContainer.OPTIONSFilter)
+}
+
+func ExampleContainer() {
+	// The Default container of go-restful uses the http.DefaultServeMux.
+	// You can create your own Container using restful.NewContainer() and create a new http.Server for that particular container
+
+	ws := new(WebService)
+	wsContainer := NewContainer()
+	wsContainer.Add(ws)
+	server := &http.Server{Addr: ":8080", Handler: wsContainer}
+	server.ListenAndServe()
+}
+
+func ExampleCrossOriginResourceSharing() {
+	// To install this filter on the Default Container use:
+	cors := CrossOriginResourceSharing{ExposeHeaders: []string{"X-My-Header"}, CookiesAllowed: false, Container: DefaultContainer}
+	Filter(cors.Filter)
+}
+
+func ExampleServiceError() {
+	resp := new(Response)
+	resp.WriteEntity(NewError(http.StatusBadRequest, "Non-integer {id} path parameter"))
+}
+
+func ExampleBoundedCachedCompressors() {
+	// Register a compressor provider (gzip/deflate read/write) that uses
+	// a bounded cache with a maximum of 20 writers and 20 readers.
+	SetCompressorProvider(NewBoundedCachedCompressors(20, 20))
+}
--- a/vendor/github.com/emicklei/go-restful/entity_accessors.go
+++ b/vendor/github.com/emicklei/go-restful/entity_accessors.go
@ -0,0 +1,163 @@
+package restful
+
+// Copyright 2015 Ernest Micklei. All rights reserved.
+// Use of this source code is governed by a license
+// that can be found in the LICENSE file.
+
+import (
+	"encoding/json"
+	"encoding/xml"
+	"strings"
+	"sync"
+)
+
+// EntityReaderWriter can read and write values using an encoding such as JSON,XML.
+type EntityReaderWriter interface {
+	// Read a serialized version of the value from the request.
+	// The Request may have a decompressing reader. Depends on Content-Encoding.
+	Read(req *Request, v interface{}) error
+
+	// Write a serialized version of the value on the response.
+	// The Response may have a compressing writer. Depends on Accept-Encoding.
+	// status should be a valid Http Status code
+	Write(resp *Response, status int, v interface{}) error
+}
+
+// entityAccessRegistry is a singleton
+var entityAccessRegistry = &entityReaderWriters{
+	protection: new(sync.RWMutex),
+	accessors:  map[string]EntityReaderWriter{},
+}
+
+// entityReaderWriters associates MIME to an EntityReaderWriter
+type entityReaderWriters struct {
+	protection *sync.RWMutex
+	accessors  map[string]EntityReaderWriter
+}
+
+func init() {
+	RegisterEntityAccessor(MIME_JSON, NewEntityAccessorJSON(MIME_JSON))
+	RegisterEntityAccessor(MIME_XML, NewEntityAccessorXML(MIME_XML))
+}
+
+// RegisterEntityAccessor add/overrides the ReaderWriter for encoding content with this MIME type.
+func RegisterEntityAccessor(mime string, erw EntityReaderWriter) {
+	entityAccessRegistry.protection.Lock()
+	defer entityAccessRegistry.protection.Unlock()
+	entityAccessRegistry.accessors[mime] = erw
+}
+
+// NewEntityAccessorJSON returns a new EntityReaderWriter for accessing JSON content.
+// This package is already initialized with such an accessor using the MIME_JSON contentType.
+func NewEntityAccessorJSON(contentType string) EntityReaderWriter {
+	return entityJSONAccess{ContentType: contentType}
+}
+
+// NewEntityAccessorXML returns a new EntityReaderWriter for accessing XML content.
+// This package is already initialized with such an accessor using the MIME_XML contentType.
+func NewEntityAccessorXML(contentType string) EntityReaderWriter {
+	return entityXMLAccess{ContentType: contentType}
+}
+
+// accessorAt returns the registered ReaderWriter for this MIME type.
+func (r *entityReaderWriters) accessorAt(mime string) (EntityReaderWriter, bool) {
+	r.protection.RLock()
+	defer r.protection.RUnlock()
+	er, ok := r.accessors[mime]
+	if !ok {
+		// retry with reverse lookup
+		// more expensive but we are in an exceptional situation anyway
+		for k, v := range r.accessors {
+			if strings.Contains(mime, k) {
+				return v, true
+			}
+		}
+	}
+	return er, ok
+}
+
+// entityXMLAccess is a EntityReaderWriter for XML encoding
+type entityXMLAccess struct {
+	// This is used for setting the Content-Type header when writing
+	ContentType string
+}
+
+// Read unmarshalls the value from XML
+func (e entityXMLAccess) Read(req *Request, v interface{}) error {
+	return xml.NewDecoder(req.Request.Body).Decode(v)
+}
+
+// Write marshalls the value to JSON and set the Content-Type Header.
+func (e entityXMLAccess) Write(resp *Response, status int, v interface{}) error {
+	return writeXML(resp, status, e.ContentType, v)
+}
+
+// writeXML marshalls the value to JSON and set the Content-Type Header.
+func writeXML(resp *Response, status int, contentType string, v interface{}) error {
+	if v == nil {
+		resp.WriteHeader(status)
+		// do not write a nil representation
+		return nil
+	}
+	if resp.prettyPrint {
+		// pretty output must be created and written explicitly
+		output, err := xml.MarshalIndent(v, " ", " ")
+		if err != nil {
+			return err
+		}
+		resp.Header().Set(HEADER_ContentType, contentType)
+		resp.WriteHeader(status)
+		_, err = resp.Write([]byte(xml.Header))
+		if err != nil {
+			return err
+		}
+		_, err = resp.Write(output)
+		return err
+	}
+	// not-so-pretty
+	resp.Header().Set(HEADER_ContentType, contentType)
+	resp.WriteHeader(status)
+	return xml.NewEncoder(resp).Encode(v)
+}
+
+// entityJSONAccess is a EntityReaderWriter for JSON encoding
+type entityJSONAccess struct {
+	// This is used for setting the Content-Type header when writing
+	ContentType string
+}
+
+// Read unmarshalls the value from JSON
+func (e entityJSONAccess) Read(req *Request, v interface{}) error {
+	decoder := json.NewDecoder(req.Request.Body)
+	decoder.UseNumber()
+	return decoder.Decode(v)
+}
+
+// Write marshalls the value to JSON and set the Content-Type Header.
+func (e entityJSONAccess) Write(resp *Response, status int, v interface{}) error {
+	return writeJSON(resp, status, e.ContentType, v)
+}
+
+// write marshalls the value to JSON and set the Content-Type Header.
+func writeJSON(resp *Response, status int, contentType string, v interface{}) error {
+	if v == nil {
+		resp.WriteHeader(status)
+		// do not write a nil representation
+		return nil
+	}
+	if resp.prettyPrint {
+		// pretty output must be created and written explicitly
+		output, err := json.MarshalIndent(v, " ", " ")
+		if err != nil {
+			return err
+		}
+		resp.Header().Set(HEADER_ContentType, contentType)
+		resp.WriteHeader(status)
+		_, err = resp.Write(output)
+		return err
+	}
+	// not-so-pretty
+	resp.Header().Set(HEADER_ContentType, contentType)
+	resp.WriteHeader(status)
+	return json.NewEncoder(resp).Encode(v)
+}
--- a/vendor/github.com/emicklei/go-restful/entity_accessors_test.go
+++ b/vendor/github.com/emicklei/go-restful/entity_accessors_test.go
@ -0,0 +1,69 @@
+package restful
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+)
+
+type keyvalue struct {
+	readCalled  bool
+	writeCalled bool
+}
+
+func (kv *keyvalue) Read(req *Request, v interface{}) error {
+	//t := reflect.TypeOf(v)
+	//rv := reflect.ValueOf(v)
+	kv.readCalled = true
+	return nil
+}
+
+func (kv *keyvalue) Write(resp *Response, status int, v interface{}) error {
+	t := reflect.TypeOf(v)
+	rv := reflect.ValueOf(v)
+	for ix := 0; ix < t.NumField(); ix++ {
+		sf := t.Field(ix)
+		io.WriteString(resp, sf.Name)
+		io.WriteString(resp, "=")
+		io.WriteString(resp, fmt.Sprintf("%v\n", rv.Field(ix).Interface()))
+	}
+	kv.writeCalled = true
+	return nil
+}
+
+// go test -v -test.run TestKeyValueEncoding ...restful
+func TestKeyValueEncoding(t *testing.T) {
+	type Book struct {
+		Title         string
+		Author        string
+		PublishedYear int
+	}
+	kv := new(keyvalue)
+	RegisterEntityAccessor("application/kv", kv)
+	b := Book{"Singing for Dummies", "john doe", 2015}
+
+	// Write
+	httpWriter := httptest.NewRecorder()
+	//								Accept									Produces
+	resp := Response{ResponseWriter: httpWriter, requestAccept: "application/kv,*/*;q=0.8", routeProduces: []string{"application/kv"}, prettyPrint: true}
+	resp.WriteEntity(b)
+	t.Log(string(httpWriter.Body.Bytes()))
+	if !kv.writeCalled {
+		t.Error("Write never called")
+	}
+
+	// Read
+	bodyReader := bytes.NewReader(httpWriter.Body.Bytes())
+	httpRequest, _ := http.NewRequest("GET", "/test", bodyReader)
+	httpRequest.Header.Set("Content-Type", "application/kv; charset=UTF-8")
+	request := NewRequest(httpRequest)
+	var bb Book
+	request.ReadEntity(&bb)
+	if !kv.readCalled {
+		t.Error("Read never called")
+	}
+}
--- a/vendor/github.com/emicklei/go-restful/examples/.goconvey
+++ b/vendor/github.com/emicklei/go-restful/examples/.goconvey
@ -0,0 +1 @@
+ignore
--- a/vendor/github.com/emicklei/go-restful/examples/google_app_engine/.goconvey
+++ b/vendor/github.com/emicklei/go-restful/examples/google_app_engine/.goconvey
@ -0,0 +1 @@
+ignore
--- a/vendor/github.com/emicklei/go-restful/examples/google_app_engine/app.yaml
+++ b/vendor/github.com/emicklei/go-restful/examples/google_app_engine/app.yaml
@ -0,0 +1,20 @@
+#
+# Include your application ID here
+#
+application: <your_app_id>
+version: 1
+runtime: go
+api_version: go1
+
+handlers:
+#
+# Regex for all swagger files to make as static content.
+# You should create the folder static/swagger and copy
+# swagger-ui into it.
+#
+- url: /apidocs/(.*?)/(.*\.(js|html|css))
+  static_files: static/swagger/\1/\2
+  upload: static/swagger/(.*?)/(.*\.(js|html|css))
+
+- url: /.*
+  script: _go_app
--- a/vendor/github.com/emicklei/go-restful/examples/google_app_engine/datastore/.goconvey
+++ b/vendor/github.com/emicklei/go-restful/examples/google_app_engine/datastore/.goconvey
@ -0,0 +1 @@
+ignore
--- a/vendor/github.com/emicklei/go-restful/examples/google_app_engine/datastore/app.yaml
+++ b/vendor/github.com/emicklei/go-restful/examples/google_app_engine/datastore/app.yaml
@ -0,0 +1,18 @@
+application: <your_app_id>
+version: 1
+runtime: go
+api_version: go1
+
+handlers:
+# Regex for all swagger files to make as static content.
+# You should create the folder static/swagger and copy
+# swagger-ui into it.
+#
+- url: /apidocs/(.*?)/(.*\.(js|html|css))
+  static_files: static/swagger/\1/\2
+  upload: static/swagger/(.*?)/(.*\.(js|html|css))
+
+# Catch all.
+- url: /.*
+  script: _go_app
+  login: required
--- a/vendor/github.com/emicklei/go-restful/examples/google_app_engine/datastore/main.go
+++ b/vendor/github.com/emicklei/go-restful/examples/google_app_engine/datastore/main.go
@ -0,0 +1,267 @@
+package main
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/emicklei/go-restful"
+	"github.com/emicklei/go-restful-swagger12"
+	"google.golang.org/appengine"
+	"google.golang.org/appengine/datastore"
+	"google.golang.org/appengine/user"
+)
+
+// This example demonstrates a reasonably complete suite of RESTful operations backed
+// by DataStore on Google App Engine.
+
+// Our simple example struct.
+type Profile struct {
+	LastModified time.Time `json:"-" xml:"-"`
+	Email        string    `json:"-" xml:"-"`
+	FirstName    string    `json:"first_name" xml:"first-name"`
+	NickName     string    `json:"nick_name" xml:"nick-name"`
+	LastName     string    `json:"last_name" xml:"last-name"`
+}
+
+type ProfileApi struct {
+	Path string
+}
+
+func gaeUrl() string {
+	if appengine.IsDevAppServer() {
+		return "http://localhost:8080"
+	} else {
+		// Include your URL on App Engine here.
+		// I found no way to get AppID without appengine.Context and this always
+		// based on a http.Request.
+		return "http://federatedservices.appspot.com"
+	}
+}
+
+func init() {
+	u := ProfileApi{Path: "/profiles"}
+	u.register()
+
+	// Optionally, you can install the Swagger Service which provides a nice Web UI on your REST API
+	// You need to download the Swagger HTML5 assets and change the FilePath location in the config below.
+	// Open <your_app_id>.appspot.com/apidocs and enter
+	// Place the Swagger UI files into a folder called static/swagger if you wish to use Swagger
+	// http://<your_app_id>.appspot.com/apidocs.json in the api input field.
+	// For testing, you can use http://localhost:8080/apidocs.json
+	config := swagger.Config{
+		// You control what services are visible
+		WebServices:    restful.RegisteredWebServices(),
+		WebServicesUrl: gaeUrl(),
+		ApiPath:        "/apidocs.json",
+
+		// Optionally, specify where the UI is located
+		SwaggerPath: "/apidocs/",
+
+		// GAE support static content which is configured in your app.yaml.
+		// This example expect the swagger-ui in static/swagger so you should place it there :)
+		SwaggerFilePath: "static/swagger"}
+	swagger.InstallSwaggerService(config)
+}
+
+func (u ProfileApi) register() {
+	ws := new(restful.WebService)
+
+	ws.
+		Path(u.Path).
+		// You can specify consumes and produces per route as well.
+		Consumes(restful.MIME_JSON, restful.MIME_XML).
+		Produces(restful.MIME_JSON, restful.MIME_XML)
+
+	ws.Route(ws.POST("").To(u.insert).
+		// Swagger documentation.
+		Doc("insert a new profile").
+		Param(ws.BodyParameter("Profile", "representation of a profile").DataType("main.Profile")).
+		Reads(Profile{}))
+
+	ws.Route(ws.GET("/{profile-id}").To(u.read).
+		// Swagger documentation.
+		Doc("read a profile").
+		Param(ws.PathParameter("profile-id", "identifier for a profile").DataType("string")).
+		Writes(Profile{}))
+
+	ws.Route(ws.PUT("/{profile-id}").To(u.update).
+		// Swagger documentation.
+		Doc("update an existing profile").
+		Param(ws.PathParameter("profile-id", "identifier for a profile").DataType("string")).
+		Param(ws.BodyParameter("Profile", "representation of a profile").DataType("main.Profile")).
+		Reads(Profile{}))
+
+	ws.Route(ws.DELETE("/{profile-id}").To(u.remove).
+		// Swagger documentation.
+		Doc("remove a profile").
+		Param(ws.PathParameter("profile-id", "identifier for a profile").DataType("string")))
+
+	restful.Add(ws)
+}
+
+// POST http://localhost:8080/profiles
+// {"first_name": "Ivan", "nick_name": "Socks", "last_name": "Hawkes"}
+//
+func (u *ProfileApi) insert(r *restful.Request, w *restful.Response) {
+	c := appengine.NewContext(r.Request)
+
+	// Marshall the entity from the request into a struct.
+	p := new(Profile)
+	err := r.ReadEntity(&p)
+	if err != nil {
+		w.WriteError(http.StatusNotAcceptable, err)
+		return
+	}
+
+	// Ensure we start with a sensible value for this field.
+	p.LastModified = time.Now()
+
+	// The profile belongs to this user.
+	p.Email = user.Current(c).String()
+
+	k, err := datastore.Put(c, datastore.NewIncompleteKey(c, "profiles", nil), p)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Let them know the location of the newly created resource.
+	// TODO: Use a safe Url path append function.
+	w.AddHeader("Location", u.Path+"/"+k.Encode())
+
+	// Return the resultant entity.
+	w.WriteHeader(http.StatusCreated)
+	w.WriteEntity(p)
+}
+
+// GET http://localhost:8080/profiles/ahdkZXZ-ZmVkZXJhdGlvbi1zZXJ2aWNlc3IVCxIIcHJvZmlsZXMYgICAgICAgAoM
+//
+func (u ProfileApi) read(r *restful.Request, w *restful.Response) {
+	c := appengine.NewContext(r.Request)
+
+	// Decode the request parameter to determine the key for the entity.
+	k, err := datastore.DecodeKey(r.PathParameter("profile-id"))
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Retrieve the entity from the datastore.
+	p := Profile{}
+	if err := datastore.Get(c, k, &p); err != nil {
+		if err.Error() == "datastore: no such entity" {
+			http.Error(w, err.Error(), http.StatusNotFound)
+		} else {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+		return
+	}
+
+	// Check we own the profile before allowing them to view it.
+	// Optionally, return a 404 instead to help prevent guessing ids.
+	// TODO: Allow admins access.
+	if p.Email != user.Current(c).String() {
+		http.Error(w, "You do not have access to this resource", http.StatusForbidden)
+		return
+	}
+
+	w.WriteEntity(p)
+}
+
+// PUT http://localhost:8080/profiles/ahdkZXZ-ZmVkZXJhdGlvbi1zZXJ2aWNlc3IVCxIIcHJvZmlsZXMYgICAgICAgAoM
+// {"first_name": "Ivan", "nick_name": "Socks", "last_name": "Hawkes"}
+//
+func (u *ProfileApi) update(r *restful.Request, w *restful.Response) {
+	c := appengine.NewContext(r.Request)
+
+	// Decode the request parameter to determine the key for the entity.
+	k, err := datastore.DecodeKey(r.PathParameter("profile-id"))
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Marshall the entity from the request into a struct.
+	p := new(Profile)
+	err = r.ReadEntity(&p)
+	if err != nil {
+		w.WriteError(http.StatusNotAcceptable, err)
+		return
+	}
+
+	// Retrieve the old entity from the datastore.
+	old := Profile{}
+	if err := datastore.Get(c, k, &old); err != nil {
+		if err.Error() == "datastore: no such entity" {
+			http.Error(w, err.Error(), http.StatusNotFound)
+		} else {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+		return
+	}
+
+	// Check we own the profile before allowing them to update it.
+	// Optionally, return a 404 instead to help prevent guessing ids.
+	// TODO: Allow admins access.
+	if old.Email != user.Current(c).String() {
+		http.Error(w, "You do not have access to this resource", http.StatusForbidden)
+		return
+	}
+
+	// Since the whole entity is re-written, we need to assign any invariant fields again
+	// e.g. the owner of the entity.
+	p.Email = user.Current(c).String()
+
+	// Keep track of the last modification date.
+	p.LastModified = time.Now()
+
+	// Attempt to overwrite the old entity.
+	_, err = datastore.Put(c, k, p)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Let them know it succeeded.
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// DELETE http://localhost:8080/profiles/ahdkZXZ-ZmVkZXJhdGlvbi1zZXJ2aWNlc3IVCxIIcHJvZmlsZXMYgICAgICAgAoM
+//
+func (u *ProfileApi) remove(r *restful.Request, w *restful.Response) {
+	c := appengine.NewContext(r.Request)
+
+	// Decode the request parameter to determine the key for the entity.
+	k, err := datastore.DecodeKey(r.PathParameter("profile-id"))
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Retrieve the old entity from the datastore.
+	old := Profile{}
+	if err := datastore.Get(c, k, &old); err != nil {
+		if err.Error() == "datastore: no such entity" {
+			http.Error(w, err.Error(), http.StatusNotFound)
+		} else {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+		return
+	}
+
+	// Check we own the profile before allowing them to delete it.
+	// Optionally, return a 404 instead to help prevent guessing ids.
+	// TODO: Allow admins access.
+	if old.Email != user.Current(c).String() {
+		http.Error(w, "You do not have access to this resource", http.StatusForbidden)
+		return
+	}
+
+	// Delete the entity.
+	if err := datastore.Delete(c, k); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+
+	// Success notification.
+	w.WriteHeader(http.StatusNoContent)
+}
--- a/vendor/github.com/emicklei/go-restful/examples/google_app_engine/restful-appstats-integration.go
+++ b/vendor/github.com/emicklei/go-restful/examples/google_app_engine/restful-appstats-integration.go
@ -0,0 +1,12 @@
+package main
+
+import (
+	"github.com/mjibson/appstats"
+)
+
+func stats(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	c := appstats.NewContext(req.Request)
+	chain.ProcessFilter(req, resp)
+	c.Stats.Status = resp.StatusCode()
+	c.Save()
+}
--- a/vendor/github.com/emicklei/go-restful/examples/google_app_engine/restful-user-service.go
+++ b/vendor/github.com/emicklei/go-restful/examples/google_app_engine/restful-user-service.go
@ -0,0 +1,162 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/emicklei/go-restful"
+	"github.com/emicklei/go-restful-swagger12"
+	"google.golang.org/appengine"
+	"google.golang.org/appengine/memcache"
+)
+
+// This example is functionally the same as ../restful-user-service.go
+// but it`s supposed to run on Goole App Engine (GAE)
+//
+// contributed by ivanhawkes
+
+type User struct {
+	Id, Name string
+}
+
+type UserService struct {
+	// normally one would use DAO (data access object)
+	// but in this example we simple use memcache.
+}
+
+func (u UserService) Register() {
+	ws := new(restful.WebService)
+
+	ws.
+		Path("/users").
+		Consumes(restful.MIME_XML, restful.MIME_JSON).
+		Produces(restful.MIME_JSON, restful.MIME_XML) // you can specify this per route as well
+
+	ws.Route(ws.GET("/{user-id}").To(u.findUser).
+		// docs
+		Doc("get a user").
+		Param(ws.PathParameter("user-id", "identifier of the user").DataType("string")).
+		Writes(User{})) // on the response
+
+	ws.Route(ws.PATCH("").To(u.updateUser).
+		// docs
+		Doc("update a user").
+		Reads(User{})) // from the request
+
+	ws.Route(ws.PUT("/{user-id}").To(u.createUser).
+		// docs
+		Doc("create a user").
+		Param(ws.PathParameter("user-id", "identifier of the user").DataType("string")).
+		Reads(User{})) // from the request
+
+	ws.Route(ws.DELETE("/{user-id}").To(u.removeUser).
+		// docs
+		Doc("delete a user").
+		Param(ws.PathParameter("user-id", "identifier of the user").DataType("string")))
+
+	restful.Add(ws)
+}
+
+// GET http://localhost:8080/users/1
+//
+func (u UserService) findUser(request *restful.Request, response *restful.Response) {
+	c := appengine.NewContext(request.Request)
+	id := request.PathParameter("user-id")
+	usr := new(User)
+	_, err := memcache.Gob.Get(c, id, &usr)
+	if err != nil || len(usr.Id) == 0 {
+		response.WriteErrorString(http.StatusNotFound, "User could not be found.")
+	} else {
+		response.WriteEntity(usr)
+	}
+}
+
+// PATCH http://localhost:8080/users
+// <User><Id>1</Id><Name>Melissa Raspberry</Name></User>
+//
+func (u *UserService) updateUser(request *restful.Request, response *restful.Response) {
+	c := appengine.NewContext(request.Request)
+	usr := new(User)
+	err := request.ReadEntity(&usr)
+	if err == nil {
+		item := &memcache.Item{
+			Key:    usr.Id,
+			Object: &usr,
+		}
+		err = memcache.Gob.Set(c, item)
+		if err != nil {
+			response.WriteError(http.StatusInternalServerError, err)
+			return
+		}
+		response.WriteEntity(usr)
+	} else {
+		response.WriteError(http.StatusInternalServerError, err)
+	}
+}
+
+// PUT http://localhost:8080/users/1
+// <User><Id>1</Id><Name>Melissa</Name></User>
+//
+func (u *UserService) createUser(request *restful.Request, response *restful.Response) {
+	c := appengine.NewContext(request.Request)
+	usr := User{Id: request.PathParameter("user-id")}
+	err := request.ReadEntity(&usr)
+	if err == nil {
+		item := &memcache.Item{
+			Key:    usr.Id,
+			Object: &usr,
+		}
+		err = memcache.Gob.Add(c, item)
+		if err != nil {
+			response.WriteError(http.StatusInternalServerError, err)
+			return
+		}
+		response.WriteHeader(http.StatusCreated)
+		response.WriteEntity(usr)
+	} else {
+		response.WriteError(http.StatusInternalServerError, err)
+	}
+}
+
+// DELETE http://localhost:8080/users/1
+//
+func (u *UserService) removeUser(request *restful.Request, response *restful.Response) {
+	c := appengine.NewContext(request.Request)
+	id := request.PathParameter("user-id")
+	err := memcache.Delete(c, id)
+	if err != nil {
+		response.WriteError(http.StatusInternalServerError, err)
+	}
+}
+
+func getGaeURL() string {
+	if appengine.IsDevAppServer() {
+		return "http://localhost:8080"
+	} else {
+		/**
+		 * Include your URL on App Engine here.
+		 * I found no way to get AppID without appengine.Context and this always
+		 * based on a http.Request.
+		 */
+		return "http://<your_app_id>.appspot.com"
+	}
+}
+
+func init() {
+	u := UserService{}
+	u.Register()
+
+	// Optionally, you can install the Swagger Service which provides a nice Web UI on your REST API
+	// You need to download the Swagger HTML5 assets and change the FilePath location in the config below.
+	// Open <your_app_id>.appspot.com/apidocs and enter http://<your_app_id>.appspot.com/apidocs.json in the api input field.
+	config := swagger.Config{
+		WebServices:    restful.RegisteredWebServices(), // you control what services are visible
+		WebServicesUrl: getGaeURL(),
+		ApiPath:        "/apidocs.json",
+
+		// Optionally, specify where the UI is located
+		SwaggerPath: "/apidocs/",
+		// GAE support static content which is configured in your app.yaml.
+		// This example expect the swagger-ui in static/swagger so you should place it there :)
+		SwaggerFilePath: "static/swagger"}
+	swagger.InstallSwaggerService(config)
+}
--- a/vendor/github.com/emicklei/go-restful/examples/home.html
+++ b/vendor/github.com/emicklei/go-restful/examples/home.html
@ -0,0 +1,7 @@
+<!DOCTYPE html>
+
+<html>
+<body>
+	<h1>{{.Text}}</h1>
+</body>
+</html>
--- a/vendor/github.com/emicklei/go-restful/examples/msgpack/msgpack_entity.go
+++ b/vendor/github.com/emicklei/go-restful/examples/msgpack/msgpack_entity.go
@ -0,0 +1,34 @@
+package restPack
+
+import (
+	restful "github.com/emicklei/go-restful"
+	"gopkg.in/vmihailenco/msgpack.v2"
+)
+
+const MIME_MSGPACK = "application/x-msgpack" // Accept or Content-Type used in Consumes() and/or Produces()
+
+// NewEntityAccessorMPack returns a new EntityReaderWriter for accessing MessagePack content.
+// This package is not initialized with such an accessor using the MIME_MSGPACK contentType.
+func NewEntityAccessorMsgPack() restful.EntityReaderWriter {
+	return entityMsgPackAccess{}
+}
+
+// entityOctetAccess is a EntityReaderWriter for Octet encoding
+type entityMsgPackAccess struct {
+}
+
+// Read unmarshalls the value from byte slice and using msgpack to unmarshal
+func (e entityMsgPackAccess) Read(req *restful.Request, v interface{}) error {
+	return msgpack.NewDecoder(req.Request.Body).Decode(v)
+}
+
+// Write marshals the value to byte slice and set the Content-Type Header.
+func (e entityMsgPackAccess) Write(resp *restful.Response, status int, v interface{}) error {
+	if v == nil {
+		resp.WriteHeader(status)
+		// do not write a nil representation
+		return nil
+	}
+	resp.WriteHeader(status)
+	return msgpack.NewEncoder(resp).Encode(v)
+}
--- a/vendor/github.com/emicklei/go-restful/examples/msgpack/msgpack_entity_test.go
+++ b/vendor/github.com/emicklei/go-restful/examples/msgpack/msgpack_entity_test.go
@ -0,0 +1,160 @@
+package restPack
+
+import (
+	"bytes"
+	"errors"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+	"time"
+
+	"io/ioutil"
+
+	restful "github.com/emicklei/go-restful"
+)
+
+func TestMsgPack(t *testing.T) {
+
+	// register msg pack entity
+	restful.RegisterEntityAccessor(MIME_MSGPACK, NewEntityAccessorMsgPack())
+	type Tool struct {
+		Name   string
+		Vendor string
+	}
+
+	// Write
+	httpWriter := httptest.NewRecorder()
+	mpack := &Tool{Name: "json", Vendor: "apple"}
+	resp := restful.NewResponse(httpWriter)
+	resp.SetRequestAccepts("application/x-msgpack,*/*;q=0.8")
+
+	err := resp.WriteEntity(mpack)
+	if err != nil {
+		t.Errorf("err %v", err)
+	}
+
+	// Read
+	bodyReader := bytes.NewReader(httpWriter.Body.Bytes())
+	httpRequest, _ := http.NewRequest("GET", "/test", bodyReader)
+	httpRequest.Header.Set("Content-Type", MIME_MSGPACK)
+	request := restful.NewRequest(httpRequest)
+	readMsgPack := new(Tool)
+	err = request.ReadEntity(&readMsgPack)
+	if err != nil {
+		t.Errorf("err %v", err)
+	}
+	if equal := reflect.DeepEqual(mpack, readMsgPack); !equal {
+		t.Fatalf("should not be error")
+	}
+}
+
+func TestWithWebService(t *testing.T) {
+	serverURL := "http://127.0.0.1:8090"
+	go func() {
+		runRestfulMsgPackRouterServer()
+	}()
+	if err := waitForServerUp(serverURL); err != nil {
+		t.Errorf("%v", err)
+	}
+
+	// send a post request
+	userData := user{Id: "0001", Name: "Tony"}
+	msgPackData, err := msgpack.Marshal(userData)
+	req, err := http.NewRequest("POST", serverURL+"/test/msgpack", bytes.NewBuffer(msgPackData))
+	req.Header.Set("Content-Type", MIME_MSGPACK)
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Errorf("unexpected error in sending req: %v", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("unexpected response: %v, expected: %v", resp.StatusCode, http.StatusOK)
+	}
+
+	ur := &userResponse{}
+	expectMsgPackDocument(t, resp, ur)
+	if ur.Status != statusActive {
+		t.Fatalf("should not error")
+	}
+	log.Printf("user response:%v", ur)
+}
+
+func expectMsgPackDocument(t *testing.T, r *http.Response, doc interface{}) {
+	data, err := ioutil.ReadAll(r.Body)
+	defer r.Body.Close()
+	if err != nil {
+		t.Errorf("ExpectMsgPackDocument: unable to read response body :%v", err)
+		return
+	}
+	// put the body back for re-reads
+	r.Body = ioutil.NopCloser(bytes.NewReader(data))
+
+	err = msgpack.Unmarshal(data, doc)
+	if err != nil {
+		t.Errorf("ExpectMsgPackDocument: unable to unmarshal MsgPack:%v", err)
+	}
+}
+
+func runRestfulMsgPackRouterServer() {
+
+	container := restful.NewContainer()
+	register(container)
+
+	log.Print("start listening on localhost:8090")
+	server := &http.Server{Addr: ":8090", Handler: container}
+	log.Fatal(server.ListenAndServe())
+}
+
+func waitForServerUp(serverURL string) error {
+	for start := time.Now(); time.Since(start) < time.Minute; time.Sleep(5 * time.Second) {
+		_, err := http.Get(serverURL + "/")
+		if err == nil {
+			return nil
+		}
+	}
+	return errors.New("waiting for server timed out")
+}
+
+var (
+	statusActive = "active"
+)
+
+type user struct {
+	Id, Name string
+}
+
+type userResponse struct {
+	Status string
+}
+
+func register(container *restful.Container) {
+	restful.RegisterEntityAccessor(MIME_MSGPACK, NewEntityAccessorMsgPack())
+	ws := new(restful.WebService)
+	ws.
+		Path("/test").
+		Consumes(restful.MIME_JSON, MIME_MSGPACK).
+		Produces(restful.MIME_JSON, MIME_MSGPACK)
+	// route user api
+	ws.Route(ws.POST("/msgpack").
+		To(do).
+		Reads(user{}).
+		Writes(userResponse{}))
+	container.Add(ws)
+}
+
+func do(request *restful.Request, response *restful.Response) {
+	u := &user{}
+	err := request.ReadEntity(u)
+	if err != nil {
+		log.Printf("should be no error, got:%v", err)
+	}
+	log.Printf("got:%v", u)
+
+	ur := &userResponse{Status: statusActive}
+
+	response.SetRequestAccepts(MIME_MSGPACK)
+	response.WriteEntity(ur)
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-CORS-filter.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-CORS-filter.go
@ -0,0 +1,68 @@
+package main
+
+import (
+	"io"
+	"log"
+	"net/http"
+
+	"github.com/emicklei/go-restful"
+)
+
+// Cross-origin resource sharing (CORS) is a mechanism that allows JavaScript on a web page
+// to make XMLHttpRequests to another domain, not the domain the JavaScript originated from.
+//
+// http://en.wikipedia.org/wiki/Cross-origin_resource_sharing
+// http://enable-cors.org/server.html
+//
+// GET http://localhost:8080/users
+//
+// GET http://localhost:8080/users/1
+//
+// PUT http://localhost:8080/users/1
+//
+// DELETE http://localhost:8080/users/1
+//
+// OPTIONS http://localhost:8080/users/1  with Header "Origin" set to some domain and
+
+type UserResource struct{}
+
+func (u UserResource) RegisterTo(container *restful.Container) {
+	ws := new(restful.WebService)
+	ws.
+		Path("/users").
+		Consumes("*/*").
+		Produces("*/*")
+
+	ws.Route(ws.GET("/{user-id}").To(u.nop))
+	ws.Route(ws.POST("").To(u.nop))
+	ws.Route(ws.PUT("/{user-id}").To(u.nop))
+	ws.Route(ws.DELETE("/{user-id}").To(u.nop))
+
+	container.Add(ws)
+}
+
+func (u UserResource) nop(request *restful.Request, response *restful.Response) {
+	io.WriteString(response.ResponseWriter, "this would be a normal response")
+}
+
+func main() {
+	wsContainer := restful.NewContainer()
+	u := UserResource{}
+	u.RegisterTo(wsContainer)
+
+	// Add container filter to enable CORS
+	cors := restful.CrossOriginResourceSharing{
+		ExposeHeaders:  []string{"X-My-Header"},
+		AllowedHeaders: []string{"Content-Type", "Accept"},
+		AllowedMethods: []string{"GET", "POST"},
+		CookiesAllowed: false,
+		Container:      wsContainer}
+	wsContainer.Filter(cors.Filter)
+
+	// Add container filter to respond to OPTIONS
+	wsContainer.Filter(wsContainer.OPTIONSFilter)
+
+	log.Print("start listening on localhost:8080")
+	server := &http.Server{Addr: ":8080", Handler: wsContainer}
+	log.Fatal(server.ListenAndServe())
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-NCSA-logging.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-NCSA-logging.go
@ -0,0 +1,54 @@
+package main
+
+import (
+	"github.com/emicklei/go-restful"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+)
+
+// This example shows how to create a filter that produces log lines
+// according to the Common Log Format, also known as the NCSA standard.
+//
+// kindly contributed by leehambley
+//
+// GET http://localhost:8080/ping
+
+var logger *log.Logger = log.New(os.Stdout, "", 0)
+
+func NCSACommonLogFormatLogger() restful.FilterFunction {
+	return func(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+		var username = "-"
+		if req.Request.URL.User != nil {
+			if name := req.Request.URL.User.Username(); name != "" {
+				username = name
+			}
+		}
+		chain.ProcessFilter(req, resp)
+		logger.Printf("%s - %s [%s] \"%s %s %s\" %d %d",
+			strings.Split(req.Request.RemoteAddr, ":")[0],
+			username,
+			time.Now().Format("02/Jan/2006:15:04:05 -0700"),
+			req.Request.Method,
+			req.Request.URL.RequestURI(),
+			req.Request.Proto,
+			resp.StatusCode(),
+			resp.ContentLength(),
+		)
+	}
+}
+
+func main() {
+	ws := new(restful.WebService)
+	ws.Filter(NCSACommonLogFormatLogger())
+	ws.Route(ws.GET("/ping").To(hello))
+	restful.Add(ws)
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func hello(req *restful.Request, resp *restful.Response) {
+	io.WriteString(resp, "pong")
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-basic-authentication.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-basic-authentication.go
@ -0,0 +1,35 @@
+package main
+
+import (
+	"github.com/emicklei/go-restful"
+	"io"
+	"log"
+	"net/http"
+)
+
+// This example shows how to create a (Route) Filter that performs Basic Authentication on the Http request.
+//
+// GET http://localhost:8080/secret
+// and use admin,admin for the credentials
+
+func main() {
+	ws := new(restful.WebService)
+	ws.Route(ws.GET("/secret").Filter(basicAuthenticate).To(secret))
+	restful.Add(ws)
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func basicAuthenticate(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	// usr/pwd = admin/admin
+	u, p, ok := req.Request.BasicAuth()
+	if !ok || u != "admin" || p != "admin" {
+		resp.AddHeader("WWW-Authenticate", "Basic realm=Protected Area")
+		resp.WriteErrorString(401, "401: Not Authorized")
+		return
+	}
+	chain.ProcessFilter(req, resp)
+}
+
+func secret(req *restful.Request, resp *restful.Response) {
+	io.WriteString(resp, "42")
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-cpuprofiler-service.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-cpuprofiler-service.go
@ -0,0 +1,65 @@
+package main
+
+import (
+	"github.com/emicklei/go-restful"
+	"io"
+	"log"
+	"os"
+	"runtime/pprof"
+)
+
+// ProfilingService is a WebService that can start/stop a CPU profile and write results to a file
+// 	GET /{rootPath}/start will activate CPU profiling
+//	GET /{rootPath}/stop will stop profiling
+//
+// NewProfileService("/profiler", "ace.prof").AddWebServiceTo(restful.DefaultContainer)
+//
+type ProfilingService struct {
+	rootPath   string   // the base (root) of the service, e.g. /profiler
+	cpuprofile string   // the output filename to write profile results, e.g. myservice.prof
+	cpufile    *os.File // if not nil, then profiling is active
+}
+
+func NewProfileService(rootPath string, outputFilename string) *ProfilingService {
+	ps := new(ProfilingService)
+	ps.rootPath = rootPath
+	ps.cpuprofile = outputFilename
+	return ps
+}
+
+// Add this ProfileService to a restful Container
+func (p ProfilingService) AddWebServiceTo(container *restful.Container) {
+	ws := new(restful.WebService)
+	ws.Path(p.rootPath).Consumes("*/*").Produces(restful.MIME_JSON)
+	ws.Route(ws.GET("/start").To(p.startProfiler))
+	ws.Route(ws.GET("/stop").To(p.stopProfiler))
+	container.Add(ws)
+}
+
+func (p *ProfilingService) startProfiler(req *restful.Request, resp *restful.Response) {
+	if p.cpufile != nil {
+		io.WriteString(resp.ResponseWriter, "[restful] CPU profiling already running")
+		return // error?
+	}
+	cpufile, err := os.Create(p.cpuprofile)
+	if err != nil {
+		log.Fatal(err)
+	}
+	// remember for close
+	p.cpufile = cpufile
+	pprof.StartCPUProfile(cpufile)
+	io.WriteString(resp.ResponseWriter, "[restful] CPU profiling started, writing on:"+p.cpuprofile)
+}
+
+func (p *ProfilingService) stopProfiler(req *restful.Request, resp *restful.Response) {
+	if p.cpufile == nil {
+		io.WriteString(resp.ResponseWriter, "[restful] CPU profiling not active")
+		return // error?
+	}
+	pprof.StopCPUProfile()
+	p.cpufile.Close()
+	p.cpufile = nil
+	io.WriteString(resp.ResponseWriter, "[restful] CPU profiling stopped, closing:"+p.cpuprofile)
+}
+
+func main() {} // exists for example compilation only
--- a/vendor/github.com/emicklei/go-restful/examples/restful-curly-router.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-curly-router.go
@ -0,0 +1,107 @@
+package main
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/emicklei/go-restful"
+)
+
+// This example has the same service definition as restful-user-resource
+// but uses a different router (CurlyRouter) that does not use regular expressions
+//
+// POST http://localhost:8080/users
+// <User><Id>1</Id><Name>Melissa Raspberry</Name></User>
+//
+// GET http://localhost:8080/users/1
+//
+// PUT http://localhost:8080/users/1
+// <User><Id>1</Id><Name>Melissa</Name></User>
+//
+// DELETE http://localhost:8080/users/1
+//
+
+type User struct {
+	Id, Name string
+}
+
+type UserResource struct {
+	// normally one would use DAO (data access object)
+	users map[string]User
+}
+
+func (u UserResource) Register(container *restful.Container) {
+	ws := new(restful.WebService)
+	ws.
+		Path("/users").
+		Consumes(restful.MIME_XML, restful.MIME_JSON).
+		Produces(restful.MIME_JSON, restful.MIME_XML) // you can specify this per route as well
+
+	ws.Route(ws.GET("/{user-id}").To(u.findUser))
+	ws.Route(ws.POST("").To(u.updateUser))
+	ws.Route(ws.PUT("/{user-id}").To(u.createUser))
+	ws.Route(ws.DELETE("/{user-id}").To(u.removeUser))
+
+	container.Add(ws)
+}
+
+// GET http://localhost:8080/users/1
+//
+func (u UserResource) findUser(request *restful.Request, response *restful.Response) {
+	id := request.PathParameter("user-id")
+	usr := u.users[id]
+	if len(usr.Id) == 0 {
+		response.AddHeader("Content-Type", "text/plain")
+		response.WriteErrorString(http.StatusNotFound, "User could not be found.")
+	} else {
+		response.WriteEntity(usr)
+	}
+}
+
+// POST http://localhost:8080/users
+// <User><Id>1</Id><Name>Melissa Raspberry</Name></User>
+//
+func (u *UserResource) updateUser(request *restful.Request, response *restful.Response) {
+	usr := new(User)
+	err := request.ReadEntity(&usr)
+	if err == nil {
+		u.users[usr.Id] = *usr
+		response.WriteEntity(usr)
+	} else {
+		response.AddHeader("Content-Type", "text/plain")
+		response.WriteErrorString(http.StatusInternalServerError, err.Error())
+	}
+}
+
+// PUT http://localhost:8080/users/1
+// <User><Id>1</Id><Name>Melissa</Name></User>
+//
+func (u *UserResource) createUser(request *restful.Request, response *restful.Response) {
+	usr := User{Id: request.PathParameter("user-id")}
+	err := request.ReadEntity(&usr)
+	if err == nil {
+		u.users[usr.Id] = usr
+		response.WriteHeaderAndEntity(http.StatusCreated, usr)
+	} else {
+		response.AddHeader("Content-Type", "text/plain")
+		response.WriteErrorString(http.StatusInternalServerError, err.Error())
+	}
+}
+
+// DELETE http://localhost:8080/users/1
+//
+func (u *UserResource) removeUser(request *restful.Request, response *restful.Response) {
+	id := request.PathParameter("user-id")
+	delete(u.users, id)
+}
+
+func main() {
+	wsContainer := restful.NewContainer()
+	wsContainer.Router(restful.CurlyRouter{})
+	u := UserResource{map[string]User{}}
+	u.Register(wsContainer)
+
+	log.Print("start listening on localhost:8080")
+	server := &http.Server{Addr: ":8080", Handler: wsContainer}
+	log.Fatal(server.ListenAndServe())
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-curly-router_test.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-curly-router_test.go
@ -0,0 +1,149 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"log"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/emicklei/go-restful"
+)
+
+type User struct {
+	Id, Name string
+}
+
+type UserResource struct {
+	users map[string]User
+}
+
+func (u UserResource) Register(container *restful.Container) {
+	ws := new(restful.WebService)
+	ws.
+		Path("/users").
+		Consumes(restful.MIME_XML, restful.MIME_JSON).
+		Produces(restful.MIME_JSON, restful.MIME_XML)
+
+	ws.Route(ws.GET("/{user-id}").To(u.findUser))
+	ws.Route(ws.POST("").To(u.updateUser))
+	ws.Route(ws.PUT("/{user-id}").To(u.createUser))
+	ws.Route(ws.DELETE("/{user-id}").To(u.removeUser))
+
+	container.Add(ws)
+}
+
+// GET http://localhost:8090/users/1
+//
+func (u UserResource) findUser(request *restful.Request, response *restful.Response) {
+	id := request.PathParameter("user-id")
+	usr := u.users[id]
+	if len(usr.Id) == 0 {
+		response.AddHeader("Content-Type", "text/plain")
+		response.WriteErrorString(http.StatusNotFound, "User could not be found.")
+	} else {
+		response.WriteEntity(usr)
+	}
+}
+
+// POST http://localhost:8090/users
+// <User><Id>1</Id><Name>Melissa Raspberry</Name></User>
+//
+func (u *UserResource) updateUser(request *restful.Request, response *restful.Response) {
+	usr := new(User)
+	err := request.ReadEntity(&usr)
+	if err == nil {
+		u.users[usr.Id] = *usr
+		response.WriteEntity(usr)
+	} else {
+		response.AddHeader("Content-Type", "text/plain")
+		response.WriteErrorString(http.StatusInternalServerError, err.Error())
+	}
+}
+
+// PUT http://localhost:8090/users/1
+// <User><Id>1</Id><Name>Melissa</Name></User>
+//
+func (u *UserResource) createUser(request *restful.Request, response *restful.Response) {
+	usr := User{Id: request.PathParameter("user-id")}
+	err := request.ReadEntity(&usr)
+	if err == nil {
+		u.users[usr.Id] = usr
+		response.WriteHeader(http.StatusCreated)
+		response.WriteEntity(usr)
+	} else {
+		response.AddHeader("Content-Type", "text/plain")
+		response.WriteErrorString(http.StatusInternalServerError, err.Error())
+	}
+}
+
+// DELETE http://localhost:8090/users/1
+//
+func (u *UserResource) removeUser(request *restful.Request, response *restful.Response) {
+	id := request.PathParameter("user-id")
+	delete(u.users, id)
+}
+
+func RunRestfulCurlyRouterServer() {
+	wsContainer := restful.NewContainer()
+	wsContainer.Router(restful.CurlyRouter{})
+	u := UserResource{map[string]User{}}
+	u.Register(wsContainer)
+
+	log.Print("start listening on localhost:8090")
+	server := &http.Server{Addr: ":8090", Handler: wsContainer}
+	log.Fatal(server.ListenAndServe())
+}
+
+func waitForServerUp(serverURL string) error {
+	for start := time.Now(); time.Since(start) < time.Minute; time.Sleep(5 * time.Second) {
+		_, err := http.Get(serverURL + "/")
+		if err == nil {
+			return nil
+		}
+	}
+	return errors.New("waiting for server timed out")
+}
+
+func TestServer(t *testing.T) {
+	serverURL := "http://localhost:8090"
+	go func() {
+		RunRestfulCurlyRouterServer()
+	}()
+	if err := waitForServerUp(serverURL); err != nil {
+		t.Errorf("%v", err)
+	}
+
+	// GET should give a 405
+	resp, err := http.Get(serverURL + "/users/")
+	if err != nil {
+		t.Errorf("unexpected error in GET /users/: %v", err)
+	}
+	if resp.StatusCode != http.StatusMethodNotAllowed {
+		t.Errorf("unexpected response: %v, expected: %v", resp.StatusCode, http.StatusOK)
+	}
+
+	// Send a POST request.
+	var jsonStr = []byte(`{"id":"1","name":"user1"}`)
+	req, err := http.NewRequest("POST", serverURL+"/users/", bytes.NewBuffer(jsonStr))
+	req.Header.Set("Content-Type", restful.MIME_JSON)
+
+	client := &http.Client{}
+	resp, err = client.Do(req)
+	if err != nil {
+		t.Errorf("unexpected error in sending req: %v", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("unexpected response: %v, expected: %v", resp.StatusCode, http.StatusOK)
+	}
+
+	// Test that GET works.
+	resp, err = http.Get(serverURL + "/users/1")
+	if err != nil {
+		t.Errorf("unexpected error in GET /users/1: %v", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("unexpected response: %v, expected: %v", resp.StatusCode, http.StatusOK)
+	}
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-encoding-filter.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-encoding-filter.go
@ -0,0 +1,61 @@
+package main
+
+import (
+	"github.com/emicklei/go-restful"
+	"log"
+	"net/http"
+)
+
+type User struct {
+	Id, Name string
+}
+
+type UserList struct {
+	Users []User
+}
+
+//
+// This example shows how to use the CompressingResponseWriter by a Filter
+// such that encoding can be enabled per WebService or per Route (instead of per container)
+// Using restful.DefaultContainer.EnableContentEncoding(true) will encode all responses served by WebServices in the DefaultContainer.
+//
+// Set Accept-Encoding to gzip or deflate
+// GET http://localhost:8080/users/42
+// and look at the response headers
+
+func main() {
+	restful.Add(NewUserService())
+	log.Print("start listening on localhost:8080")
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func NewUserService() *restful.WebService {
+	ws := new(restful.WebService)
+	ws.
+		Path("/users").
+		Consumes(restful.MIME_XML, restful.MIME_JSON).
+		Produces(restful.MIME_JSON, restful.MIME_XML)
+
+	// install a response encoding filter
+	ws.Route(ws.GET("/{user-id}").Filter(encodingFilter).To(findUser))
+	return ws
+}
+
+// Route Filter (defines FilterFunction)
+func encodingFilter(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	log.Printf("[encoding-filter] %s,%s\n", req.Request.Method, req.Request.URL)
+	// wrap responseWriter into a compressing one
+	compress, _ := restful.NewCompressingResponseWriter(resp.ResponseWriter, restful.ENCODING_GZIP)
+	resp.ResponseWriter = compress
+	defer func() {
+		compress.Close()
+	}()
+	chain.ProcessFilter(req, resp)
+}
+
+// GET http://localhost:8080/users/42
+//
+func findUser(request *restful.Request, response *restful.Response) {
+	log.Print("findUser")
+	response.WriteEntity(User{"42", "Gandalf"})
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-filters.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-filters.go
@ -0,0 +1,114 @@
+package main
+
+import (
+	"github.com/emicklei/go-restful"
+	"log"
+	"net/http"
+	"time"
+)
+
+type User struct {
+	Id, Name string
+}
+
+type UserList struct {
+	Users []User
+}
+
+// This example show how to create and use the three different Filters (Container,WebService and Route)
+// When applied to the restful.DefaultContainer, we refer to them as a global filter.
+//
+// GET  http://localhost:8080/users/42
+// and see the logging per filter (try repeating this request)
+
+func main() {
+	// install a global (=DefaultContainer) filter (processed before any webservice in the DefaultContainer)
+	restful.Filter(globalLogging)
+
+	restful.Add(NewUserService())
+	log.Print("start listening on localhost:8080")
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func NewUserService() *restful.WebService {
+	ws := new(restful.WebService)
+	ws.
+		Path("/users").
+		Consumes(restful.MIME_XML, restful.MIME_JSON).
+		Produces(restful.MIME_JSON, restful.MIME_XML)
+
+	// install a webservice filter (processed before any route)
+	ws.Filter(webserviceLogging).Filter(measureTime)
+
+	// install a counter filter
+	ws.Route(ws.GET("").Filter(NewCountFilter().routeCounter).To(getAllUsers))
+
+	// install 2 chained route filters (processed before calling findUser)
+	ws.Route(ws.GET("/{user-id}").Filter(routeLogging).Filter(NewCountFilter().routeCounter).To(findUser))
+	return ws
+}
+
+// Global Filter
+func globalLogging(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	log.Printf("[global-filter (logger)] %s,%s\n", req.Request.Method, req.Request.URL)
+	chain.ProcessFilter(req, resp)
+}
+
+// WebService Filter
+func webserviceLogging(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	log.Printf("[webservice-filter (logger)] %s,%s\n", req.Request.Method, req.Request.URL)
+	chain.ProcessFilter(req, resp)
+}
+
+// WebService (post-process) Filter (as a struct that defines a FilterFunction)
+func measureTime(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	now := time.Now()
+	chain.ProcessFilter(req, resp)
+	log.Printf("[webservice-filter (timer)] %v\n", time.Now().Sub(now))
+}
+
+// Route Filter (defines FilterFunction)
+func routeLogging(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	log.Printf("[route-filter (logger)] %s,%s\n", req.Request.Method, req.Request.URL)
+	chain.ProcessFilter(req, resp)
+}
+
+// Route Filter (as a struct that defines a FilterFunction)
+// CountFilter implements a FilterFunction for counting requests.
+type CountFilter struct {
+	count   int
+	counter chan int // for go-routine safe count increments
+}
+
+// NewCountFilter creates and initializes a new CountFilter.
+func NewCountFilter() *CountFilter {
+	c := new(CountFilter)
+	c.counter = make(chan int)
+	go func() {
+		for {
+			c.count += <-c.counter
+		}
+	}()
+	return c
+}
+
+// routeCounter increments the count of the filter (through a channel)
+func (c *CountFilter) routeCounter(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	c.counter <- 1
+	log.Printf("[route-filter (counter)] count:%d", c.count)
+	chain.ProcessFilter(req, resp)
+}
+
+// GET http://localhost:8080/users
+//
+func getAllUsers(request *restful.Request, response *restful.Response) {
+	log.Print("getAllUsers")
+	response.WriteEntity(UserList{[]User{{"42", "Gandalf"}, {"3.14", "Pi"}}})
+}
+
+// GET http://localhost:8080/users/42
+//
+func findUser(request *restful.Request, response *restful.Response) {
+	log.Print("findUser")
+	response.WriteEntity(User{"42", "Gandalf"})
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-form-handling.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-form-handling.go
@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+	"github.com/emicklei/go-restful"
+	"github.com/gorilla/schema"
+	"io"
+	"log"
+	"net/http"
+)
+
+// This example shows how to handle a POST of a HTML form that uses the standard x-www-form-urlencoded content-type.
+// It uses the gorilla web tool kit schema package to decode the form data into a struct.
+//
+// GET http://localhost:8080/profiles
+//
+
+type Profile struct {
+	Name string
+	Age  int
+}
+
+var decoder *schema.Decoder
+
+func main() {
+	decoder = schema.NewDecoder()
+	ws := new(restful.WebService)
+	ws.Route(ws.POST("/profiles").Consumes("application/x-www-form-urlencoded").To(postAdddress))
+	ws.Route(ws.GET("/profiles").To(addresssForm))
+	restful.Add(ws)
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func postAdddress(req *restful.Request, resp *restful.Response) {
+	err := req.Request.ParseForm()
+	if err != nil {
+		resp.WriteErrorString(http.StatusBadRequest, err.Error())
+		return
+	}
+	p := new(Profile)
+	err = decoder.Decode(p, req.Request.PostForm)
+	if err != nil {
+		resp.WriteErrorString(http.StatusBadRequest, err.Error())
+		return
+	}
+	io.WriteString(resp.ResponseWriter, fmt.Sprintf("<html><body>Name=%s, Age=%d</body></html>", p.Name, p.Age))
+}
+
+func addresssForm(req *restful.Request, resp *restful.Response) {
+	io.WriteString(resp.ResponseWriter,
+		`<html>
+		<body>
+		<h1>Enter Profile</h1>
+		<form method="post">
+		    <label>Name:</label>
+			<input type="text" name="Name"/>
+			<label>Age:</label>
+		    <input type="text" name="Age"/>
+			<input type="Submit" />
+		</form>
+		</body>
+		</html>`)
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-hello-world.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-hello-world.go
@ -0,0 +1,23 @@
+package main
+
+import (
+	"github.com/emicklei/go-restful"
+	"io"
+	"log"
+	"net/http"
+)
+
+// This example shows the minimal code needed to get a restful.WebService working.
+//
+// GET http://localhost:8080/hello
+
+func main() {
+	ws := new(restful.WebService)
+	ws.Route(ws.GET("/hello").To(hello))
+	restful.Add(ws)
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func hello(req *restful.Request, resp *restful.Response) {
+	io.WriteString(resp, "world")
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-html-template.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-html-template.go
@ -0,0 +1,35 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"text/template"
+
+	"github.com/emicklei/go-restful"
+)
+
+// This example shows how to serve a HTML page using the standard Go template engine.
+//
+// GET http://localhost:8080/
+
+func main() {
+	ws := new(restful.WebService)
+	ws.Route(ws.GET("/").To(home))
+	restful.Add(ws)
+	print("open browser on http://localhost:8080/\n")
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+type Message struct {
+	Text string
+}
+
+func home(req *restful.Request, resp *restful.Response) {
+	p := &Message{"restful-html-template demo"}
+	// you might want to cache compiled templates
+	t, err := template.ParseFiles("home.html")
+	if err != nil {
+		log.Fatalf("Template gave: %s", err)
+	}
+	t.Execute(resp.ResponseWriter, p)
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-multi-containers.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-multi-containers.go
@ -0,0 +1,43 @@
+package main
+
+import (
+	"github.com/emicklei/go-restful"
+	"io"
+	"log"
+	"net/http"
+)
+
+// This example shows how to have a program with 2 WebServices containers
+// each having a http server listening on its own port.
+//
+// The first "hello" is added to the restful.DefaultContainer (and uses DefaultServeMux)
+// For the second "hello", a new container and ServeMux is created
+// and requires a new http.Server with the container being the Handler.
+// This first server is spawn in its own go-routine such that the program proceeds to create the second.
+//
+// GET http://localhost:8080/hello
+// GET http://localhost:8081/hello
+
+func main() {
+	ws := new(restful.WebService)
+	ws.Route(ws.GET("/hello").To(hello))
+	restful.Add(ws)
+	go func() {
+		log.Fatal(http.ListenAndServe(":8080", nil))
+	}()
+
+	container2 := restful.NewContainer()
+	ws2 := new(restful.WebService)
+	ws2.Route(ws2.GET("/hello").To(hello2))
+	container2.Add(ws2)
+	server := &http.Server{Addr: ":8081", Handler: container2}
+	log.Fatal(server.ListenAndServe())
+}
+
+func hello(req *restful.Request, resp *restful.Response) {
+	io.WriteString(resp, "default world")
+}
+
+func hello2(req *restful.Request, resp *restful.Response) {
+	io.WriteString(resp, "second world")
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-no-cache-filter.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-no-cache-filter.go
@ -0,0 +1,25 @@
+package main
+
+import (
+	"io"
+	"log"
+	"net/http"
+
+	"github.com/emicklei/go-restful"
+)
+
+// This example shows how to use a WebService filter that passed the Http headers to disable browser cacheing.
+//
+// GET http://localhost:8080/hello
+
+func main() {
+	ws := new(restful.WebService)
+	ws.Filter(restful.NoBrowserCacheFilter)
+	ws.Route(ws.GET("/hello").To(hello))
+	restful.Add(ws)
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func hello(req *restful.Request, resp *restful.Response) {
+	io.WriteString(resp, "world")
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-options-filter.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-options-filter.go
@ -0,0 +1,51 @@
+package main
+
+import (
+	"github.com/emicklei/go-restful"
+	"io"
+	"log"
+	"net/http"
+)
+
+// This example shows how to use the OPTIONSFilter on a Container
+//
+// OPTIONS http://localhost:8080/users
+//
+// OPTIONS http://localhost:8080/users/1
+
+type UserResource struct{}
+
+func (u UserResource) RegisterTo(container *restful.Container) {
+	ws := new(restful.WebService)
+	ws.
+		Path("/users").
+		Consumes("*/*").
+		Produces("*/*")
+
+	ws.Route(ws.GET("/{user-id}").To(u.nop))
+	ws.Route(ws.POST("").To(u.nop))
+	ws.Route(ws.PUT("/{user-id}").To(u.nop))
+	ws.Route(ws.DELETE("/{user-id}").To(u.nop))
+
+	container.Add(ws)
+}
+
+func (u UserResource) nop(request *restful.Request, response *restful.Response) {
+	io.WriteString(response.ResponseWriter, "this would be a normal response")
+}
+
+func main() {
+	wsContainer := restful.NewContainer()
+	u := UserResource{}
+	u.RegisterTo(wsContainer)
+
+	// Add container filter to respond to OPTIONS
+	wsContainer.Filter(wsContainer.OPTIONSFilter)
+
+	// For use on the default container, you can write
+	// restful.Filter(restful.OPTIONSFilter())
+
+	log.Print("start listening on localhost:8080")
+	server := &http.Server{Addr: ":8080", Handler: wsContainer}
+	log.Fatal(server.ListenAndServe())
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-path-tail.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-path-tail.go
@ -0,0 +1,27 @@
+package main
+
+import (
+	. "github.com/emicklei/go-restful"
+	"io"
+	"log"
+	"net/http"
+)
+
+// This example shows how to create a Route matching the "tail" of a path.
+// Requires the use of a CurlyRouter and the star "*" path parameter pattern.
+//
+// GET http://localhost:8080/basepath/some/other/location/test.xml
+
+func main() {
+	DefaultContainer.Router(CurlyRouter{})
+	ws := new(WebService)
+	ws.Route(ws.GET("/basepath/{resource:*}").To(staticFromPathParam))
+	Add(ws)
+
+	println("[go-restful] serve path tails from http://localhost:8080/basepath")
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func staticFromPathParam(req *Request, resp *Response) {
+	io.WriteString(resp, "Tail="+req.PathParameter("resource"))
+}
--- a/vendor/github.com/emicklei/go-restful/examples/restful-pre-post-filters.go
+++ b/vendor/github.com/emicklei/go-restful/examples/restful-pre-post-filters.go
@ -0,0 +1,98 @@
+package main
+
+import (
+	"github.com/emicklei/go-restful"
+	"io"
+	"log"
+	"net/http"
+)
+
+// This example shows how the different types of filters are called in the request-response flow.
+// The call chain is logged on the console when sending an http request.
+//
+// GET http://localhost:8080/1
+// GET http://localhost:8080/2
+
+var indentLevel int
+
+func container_filter_A(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	log.Printf("url path:%v\n", req.Request.URL)
+	trace("container_filter_A: before", 1)
+	chain.ProcessFilter(req, resp)
+	trace("container_filter_A: after", -1)
+}
+
+func container_filter_B(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	trace("container_filter_B: before", 1)
+	chain.ProcessFilter(req, resp)
+	trace("container_filter_B: after", -1)
+}
+
+func service_filter_A(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	trace("service_filter_A: before", 1)
+	chain.ProcessFilter(req, resp)
+	trace("service_filter_A: after", -1)
+}
+
+func service_filter_B(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	trace("service_filter_B: before", 1)
+	chain.ProcessFilter(req, resp)
+	trace("service_filter_B: after", -1)
+}
+
+func route_filter_A(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	trace("route_filter_A: before", 1)
+	chain.ProcessFilter(req, resp)
+	trace("route_filter_A: after", -1)
+}
+
+func route_filter_B(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
+	trace("route_filter_B: before", 1)
+	chain.ProcessFilter(req, resp)
+	trace("route_filter_B: after", -1)
+}
+
+func trace(what string, delta int) {
+	indented := what
+	if delta < 0 {
+		indentLevel += delta
+	}
+	for t := 0; t < indentLevel; t++ {
+		indented = "." + indented
+	}
+	log.Printf("%s", indented)
+	if delta > 0 {
+		indentLevel += delta
+	}
+}
+
+func main() {
+	restful.Filter(container_filter_A)
+	restful.Filter(container_filter_B)
+
+	ws1 := new(restful.WebService)
+	ws1.Path("/1")
+	ws1.Filter(service_filter_A)
+	ws1.Filter(service_filter_B)
+	ws1.Route(ws1.GET("").To(doit1).Filter(route_filter_A).Filter(route_filter_B))
+
+	ws2 := new(restful.WebService)
+	ws2.Path("/2")
+	ws2.Filter(service_filter_A)
+	ws2.Filter(service_filter_B)
+	ws2.Route(ws2.GET("").To(doit2).Filter(route_filter_A).Filter(route_filter_B))
+
+	restful.Add(ws1)
+	restful.Add(ws2)
+
+	log.Print("go-restful example listing on http://localhost:8080/1 and http://localhost:8080/2")
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func doit1(req *restful.Request, resp *restful.Response) {
+	io.WriteString(resp, "nothing to see in 1")
+}
+
+func doit2(req *restful.Request, resp *restful.Response) {
+	io.WriteString(resp, "nothing to see in 2")
+}
--- a/Show More
+++ b/Show More