Add app source, add vendoring and module support

Merge pull request #1 from mayuresh82/fix_gw
Add a fix for gw ip
2019-10-16 15:57:55 -07:00 · 2019-09-12 14:44:58 -07:00 · 2019-09-12 14:44:21 -07:00 · 2018-11-26 16:44:39 -08:00 · 2018-11-21 11:25:34 -08:00 · 2018-11-21 10:57:46 -08:00
994 changed files with 505324 additions and 424 deletions
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -1,356 +0,0 @@
 # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
 [[projects]]
  branch = "master"
  digest = "1:c47f4964978e211c6e566596ec6246c329912ea92e9bb99c00798bb4564c5b09"
  name = "github.com/armon/go-radix"
  packages = ["."]
  pruneopts = "UT"
  revision = "1a2de0c21c94309923825da3df33a4381872c795"
 [[projects]]
  branch = "master"
  digest = "1:8583eab935e3d99d3a7ac489cd2ee7c8e95eecd7c64ab1fc8382746dacaf8563"
  name = "github.com/dgryski/go-farm"
  packages = ["."]
  pruneopts = "UT"
  revision = "2de33835d10275975374b37b2dcfd22c9020a1f5"
 [[projects]]
  digest = "1:975a4480c40f2d0b95e1f83d3ec1aa29a2774e80179e08a9a4ba2aab86721b23"
  name = "github.com/eapache/channels"
  packages = ["."]
  pruneopts = "UT"
  revision = "47238d5aae8c0fefd518ef2bee46290909cf8263"
  version = "v1.1.0"
 [[projects]]
  digest = "1:444b82bfe35c83bbcaf84e310fb81a1f9ece03edfed586483c869e2c046aef69"
  name = "github.com/eapache/queue"
  packages = ["."]
  pruneopts = "UT"
  revision = "44cc805cf13205b55f69e14bcb69867d1ae92f98"
  version = "v1.1.0"
 [[projects]]
  digest = "1:abeb38ade3f32a92943e5be54f55ed6d6e3b6602761d74b4aab4c9dd45c18abd"
  name = "github.com/fsnotify/fsnotify"
  packages = ["."]
  pruneopts = "UT"
  revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9"
  version = "v1.4.7"
 [[projects]]
  branch = "master"
  digest = "1:1ba1d79f2810270045c328ae5d674321db34e3aae468eb4233883b473c5c0467"
  name = "github.com/golang/glog"
  packages = ["."]
  pruneopts = "UT"
  revision = "23def4e6c14b4da8ac2ed8007337bc5eb5007998"
 [[projects]]
  branch = "master"
  digest = "1:c095e448622bb061a09cb718e3dddc59acb624a67756392282374fa091c83343"
  name = "github.com/golang/protobuf"
  packages = [
    "proto",
    "ptypes",
    "ptypes/any",
    "ptypes/duration",
    "ptypes/empty",
    "ptypes/timestamp",
  ]
  pruneopts = "UT"
  revision = "7be3631955993a734965532f776bad7093f6fc9d"
 [[projects]]
  digest = "1:c0d19ab64b32ce9fe5cf4ddceba78d5bc9807f0016db6b1183599da3dcc24d10"
  name = "github.com/hashicorp/hcl"
  packages = [
    ".",
    "hcl/ast",
    "hcl/parser",
    "hcl/printer",
    "hcl/scanner",
    "hcl/strconv",
    "hcl/token",
    "json/parser",
    "json/scanner",
    "json/token",
  ]
  pruneopts = "UT"
  revision = "8cb6e5b959231cc1119e43259c4a608f9c51a241"
  version = "v1.0.0"
 [[projects]]
  digest = "1:65b0a07f85f7b5cc019c26775efc278a155a5dea0a8aa617c980e8308d16bc55"
  name = "github.com/influxdata/influxdb"
  packages = [
    "client/v2",
    "models",
    "pkg/escape",
  ]
  pruneopts = "UT"
  revision = "c75cdfdfa6f71a08473fefcec71f6cbcbdef1ff4"
  version = "v1.6.4"
 [[projects]]
  digest = "1:0a69a1c0db3591fcefb47f115b224592c8dfa4368b7ba9fae509d5e16cdc95c8"
  name = "github.com/konsorten/go-windows-terminal-sequences"
  packages = ["."]
  pruneopts = "UT"
  revision = "5c8c8bd35d3832f5d134ae1e1e375b69a4d25242"
  version = "v1.0.1"
 [[projects]]
  digest = "1:c568d7727aa262c32bdf8a3f7db83614f7af0ed661474b24588de635c20024c7"
  name = "github.com/magiconair/properties"
  packages = ["."]
  pruneopts = "UT"
  revision = "c2353362d570a7bfa228149c62842019201cfb71"
  version = "v1.8.0"
 [[projects]]
  digest = "1:53bc4cd4914cd7cd52139990d5170d6dc99067ae31c56530621b18b35fc30318"
  name = "github.com/mitchellh/mapstructure"
  packages = ["."]
  pruneopts = "UT"
  revision = "3536a929edddb9a5b34bd6861dc4a9647cb459fe"
  version = "v1.1.2"
 [[projects]]
  branch = "master"
  digest = "1:7261338473c27eea9593dceecf6a949c689f6dbd2226cad46139ab9d5011bc4b"
  name = "github.com/osrg/gobgp"
  packages = [
    "api",
    "internal/pkg/apiutil",
    "internal/pkg/config",
    "internal/pkg/table",
    "internal/pkg/zebra",
    "pkg/packet/bgp",
    "pkg/packet/bmp",
    "pkg/packet/mrt",
    "pkg/packet/rtr",
    "pkg/server",
  ]
  pruneopts = "UT"
  revision = "329c2d316efecfed0331e30114d7086aa58e247e"
 [[projects]]
  digest = "1:95741de3af260a92cc5c7f3f3061e85273f5a81b5db20d4bd68da74bd521675e"
  name = "github.com/pelletier/go-toml"
  packages = ["."]
  pruneopts = "UT"
  revision = "c01d1270ff3e442a8a57cddc1c92dc1138598194"
  version = "v1.2.0"
 [[projects]]
  branch = "master"
  digest = "1:dd6ba1917df517806c9dcee5c87f15643c9b1ca6260d5b3f25eb863c6fe092ce"
  name = "github.com/satori/go.uuid"
  packages = ["."]
  pruneopts = "UT"
  revision = "8ccf5352a842c034b1a69f28c863aff9b1cdb116"
 [[projects]]
  digest = "1:3f53e9e4dfbb664cd62940c9c4b65a2171c66acd0b7621a1a6b8e78513525a52"
  name = "github.com/sirupsen/logrus"
  packages = ["."]
  pruneopts = "UT"
  revision = "ad15b42461921f1fb3529b058c6786c6a45d5162"
  version = "v1.1.1"
 [[projects]]
  digest = "1:6a4a11ba764a56d2758899ec6f3848d24698d48442ebce85ee7a3f63284526cd"
  name = "github.com/spf13/afero"
  packages = [
    ".",
    "mem",
  ]
  pruneopts = "UT"
  revision = "d40851caa0d747393da1ffb28f7f9d8b4eeffebd"
  version = "v1.1.2"
 [[projects]]
  digest = "1:516e71bed754268937f57d4ecb190e01958452336fa73dbac880894164e91c1f"
  name = "github.com/spf13/cast"
  packages = ["."]
  pruneopts = "UT"
  revision = "8965335b8c7107321228e3e3702cab9832751bac"
  version = "v1.2.0"
 [[projects]]
  digest = "1:68ea4e23713989dc20b1bded5d9da2c5f9be14ff9885beef481848edd18c26cb"
  name = "github.com/spf13/jwalterweatherman"
  packages = ["."]
  pruneopts = "UT"
  revision = "4a4406e478ca629068e7768fc33f3f044173c0a6"
  version = "v1.0.0"
 [[projects]]
  digest = "1:c1b1102241e7f645bc8e0c22ae352e8f0dc6484b6cb4d132fa9f24174e0119e2"
  name = "github.com/spf13/pflag"
  packages = ["."]
  pruneopts = "UT"
  revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
  version = "v1.0.3"
 [[projects]]
  branch = "master"
  digest = "1:748519c76ecc7b5d673d7ee8924ace736ec1717b93011c77171b8bd961ac280c"
  name = "github.com/spf13/viper"
  packages = ["."]
  pruneopts = "UT"
  revision = "62edee319679b6ceaec16de03b966102d2dea709"
 [[projects]]
  branch = "master"
  digest = "1:b046e193dd6bb64f4df01dcc12eec2ec89ba32565f025f9cb9f1d54bc3945be9"
  name = "github.com/vishvananda/netlink"
  packages = [
    ".",
    "nl",
  ]
  pruneopts = "UT"
  revision = "d3a23fd178f1a0d9cf1f194af62864b1dfe02be5"
 [[projects]]
  branch = "master"
  digest = "1:e4e30678fb2560b5c62f6308c5023d6c294fc7713216fa379411cc74465e866f"
  name = "github.com/vishvananda/netns"
  packages = ["."]
  pruneopts = "UT"
  revision = "13995c7128ccc8e51e9a6bd2b551020a27180abd"
 [[projects]]
  branch = "master"
  digest = "1:3f3a05ae0b95893d90b9b3b5afdb79a9b3d96e4e36e099d841ae602e4aca0da8"
  name = "golang.org/x/crypto"
  packages = ["ssh/terminal"]
  pruneopts = "UT"
  revision = "0c41d7ab0a0ee717d4590a44bcb987dfd9e183eb"
 [[projects]]
  branch = "master"
  digest = "1:505dbee0833715a72a529bb57c354826ad42a4496fad787fa143699b4de1a6d0"
  name = "golang.org/x/net"
  packages = [
    "context",
    "http/httpguts",
    "http2",
    "http2/hpack",
    "idna",
    "internal/timeseries",
    "trace",
  ]
  pruneopts = "UT"
  revision = "04a2e542c03f1d053ab3e4d6e5abcd4b66e2be8e"
 [[projects]]
  branch = "master"
  digest = "1:cfc31002d1ab36060fcd4a29d9f6bad6f9eeeab1dc6f5be78d37a0f825ba6dc1"
  name = "golang.org/x/sys"
  packages = [
    "unix",
    "windows",
  ]
  pruneopts = "UT"
  revision = "eda9bb28ed513021f3e6a2a361031adc3d8a6301"
 [[projects]]
  digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
  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",
  ]
  pruneopts = "UT"
  revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
  version = "v0.3.0"
 [[projects]]
  branch = "master"
  digest = "1:56b0bca90b7e5d1facf5fbdacba23e4e0ce069d25381b8e2f70ef1e7ebfb9c1a"
  name = "google.golang.org/genproto"
  packages = ["googleapis/rpc/status"]
  pruneopts = "UT"
  revision = "94acd270e44e65579b9ee3cdab25034d33fed608"
 [[projects]]
  digest = "1:ab8e92d746fb5c4c18846b0879842ac8e53b3d352449423d0924a11f1020ae1b"
  name = "google.golang.org/grpc"
  packages = [
    ".",
    "balancer",
    "balancer/base",
    "balancer/roundrobin",
    "codes",
    "connectivity",
    "credentials",
    "encoding",
    "encoding/proto",
    "grpclog",
    "internal",
    "internal/backoff",
    "internal/channelz",
    "internal/envconfig",
    "internal/grpcrand",
    "internal/transport",
    "keepalive",
    "metadata",
    "naming",
    "peer",
    "resolver",
    "resolver/dns",
    "resolver/passthrough",
    "stats",
    "status",
    "tap",
  ]
  pruneopts = "UT"
  revision = "8dea3dc473e90c8179e519d91302d0597c0ca1d1"
  version = "v1.15.0"
 [[projects]]
  branch = "v2"
  digest = "1:5bb148b78468350091db2ffbb2370f35cc6dcd74d9378a31b1c7b86ff7528f08"
  name = "gopkg.in/tomb.v2"
  packages = ["."]
  pruneopts = "UT"
  revision = "d5d1b5820637886def9eef33e03a27a9f166942c"
 [[projects]]
  digest = "1:342378ac4dcb378a5448dd723f0784ae519383532f5e70ade24132c4c8693202"
  name = "gopkg.in/yaml.v2"
  packages = ["."]
  pruneopts = "UT"
  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
  version = "v2.2.1"
 [solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
  input-imports = [
    "github.com/golang/glog",
    "github.com/golang/protobuf/ptypes",
    "github.com/golang/protobuf/ptypes/any",
    "github.com/osrg/gobgp/api",
    "github.com/osrg/gobgp/pkg/server",
    "gopkg.in/yaml.v2",
  ]
  solver-name = "gps-cdcl"
  solver-version = 1
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -1,42 +0,0 @@
 # Gopkg.toml example
 #
 # Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
 # for detailed Gopkg.toml documentation.
 #
 # required = ["github.com/user/thing/cmd/thing"]
 # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
 #
 # [[constraint]]
 #   name = "github.com/user/project"
 #   version = "1.0.0"
 #
 # [[constraint]]
 #   name = "github.com/user/project2"
 #   branch = "dev"
 #   source = "github.com/myfork/project2"
 #
 # [[override]]
 #   name = "github.com/x/y"
 #   version = "2.4.0"
 #
 # [prune]
 #   non-go = false
 #   go-tests = true
 #   unused-packages = true
 [[constraint]]
  branch = "master"
  name = "github.com/golang/glog"
 [[constraint]]
  branch = "master"
  name = "github.com/golang/protobuf"
 [[constraint]]
  branch = "master"
  name = "github.com/osrg/gobgp"
 [prune]
  go-tests = true
  unused-packages = true
--- a/15
+++ b/15
@@ -1,23 +1,16 @@
 .PHONY: all gocast test
 all:
 	$(MAKE) deps
 	$(MAKE) gocast
 deps:
 	go get -u golang.org/x/lint/golint
 	go get -u github.com/golang/dep/cmd/dep
 	dep ensure
 gocast:
-	go build .
+	go build -mod=vendor .
 debug:
-	dep ensure
+	go build -mod=vendor -race .
 	go build -race .
 test:
-	go test -v -race -short -failfast ./...
+	go test -v -race -short -failfast -mod=vendor ./...
 linux:
-	GOOS=linux GOARCH=amd64 go build -o gocast_linux .
+	GOOS=linux GOARCH=amd64 go build -o gocast_linux -mod=vendor .
--- a/controller/app.go
+++ b/controller/app.go
@@ -53,6 +53,7 @@ type App struct {
 	Vip      *net.IPNet
 	Monitors Monitors
 	Nats     []string
 	Source   string
 }
 func (a *App) Equal(other *App) bool {
@@ -67,11 +68,11 @@ func (a *App) Equal(other *App) bool {
 	return a.Name == other.Name && a.Vip.String() == other.Vip.String()
 }
-func NewApp(appName, vip string, monitors []string, nats []string) (*App, error) {
+func NewApp(appName, vip string, monitors []string, nats []string, source string) (*App, error) {
 	if appName == "" {
 		return nil, fmt.Errorf("Invalid app name")
 	}
-	app := &App{Name: appName, Nats: nats}
+	app := &App{Name: appName, Nats: nats, Source: source}
 	_, ipnet, err := net.ParseCIDR(vip)
 	if err != nil {
 		return nil, fmt.Errorf("Invalid VIP specified, need ip/mask")
--- a/controller/bgp.go
+++ b/controller/bgp.go
@@ -18,22 +18,23 @@ type Controller struct {
 	localIP, peerIP net.IP
 	communities     []string
 	origin          uint32
 	multiHop        bool
 	s               *gobgp.BgpServer
 }
 func NewController(config *c.Config) (*Controller, error) {
 	c := &Controller{}
 	var gw net.IP
 	var err error
 	if config.Bgp.PeerIP == "" {
-		gw, err := gateway()
+		gw, err = gateway()
 		if err != nil {
 			return nil, err
 		}
 		c.peerIP = gw
 	} else {
 		c.peerIP = net.ParseIP(config.Bgp.PeerIP)
 		gw, err = via(c.peerIP)
 	}
-	if c.peerIP == nil {
+	if err != nil || c.peerIP == nil {
-		return nil, fmt.Errorf("Unable to get peer IP")
+		return nil, fmt.Errorf("Unable to get peer IP : %v", err)
 	}
 	c.communities = config.Bgp.Communities
 	switch config.Bgp.Origin {
@@ -46,7 +47,7 @@ func NewController(config *c.Config) (*Controller, error) {
 	}
 	s := gobgp.NewBgpServer()
 	go s.Serve()
-	localAddr, err := localAddress(c.peerIP)
+	localAddr, err := localAddress(gw)
 	if err != nil {
 		return nil, err
 	}
@@ -62,6 +63,10 @@ func NewController(config *c.Config) (*Controller, error) {
 	}
 	c.s = s
 	c.peerAS = config.Bgp.PeerAS
 	// set mh by default for all ebgp peers
 	if c.peerAS != config.Bgp.LocalAS {
 		c.multiHop = true
 	}
 	return c, nil
 }
@@ -72,6 +77,9 @@ func (c *Controller) AddPeer(peer string) error {
 			PeerAs:          uint32(c.peerAS),
 		},
 	}
 	if c.multiHop {
 		n.EbgpMultihop = &api.EbgpMultihop{Enabled: true, MultihopTtl: uint32(255)}
 	}
 	return c.s.AddPeer(context.Background(), &api.AddPeerRequest{Peer: n})
 }
--- a/controller/consul.go
+++ b/controller/consul.go
@@ -86,7 +86,7 @@ func (c *ConsulMon) queryServices() ([]*App, error) {
 			glog.Errorf("No vip Tag found in matched service :%s", service.Service)
 			continue
 		}
-		app, err := NewApp(service.Service, vip, monitors, nats)
+		app, err := NewApp(service.Service, vip, monitors, nats, "consul")
 		if err != nil {
 			glog.Errorf("Unable to add consul app: %v", err)
 			continue
@@ -110,8 +110,13 @@ func (c *ConsulMon) healthCheck(service string) (bool, error) {
 	}
 	for _, nodeInfo := range data {
 		n := nodeInfo.(map[string]interface{})
-		if n["Node"] == c.node && n["Status"].(string) == "passing" {
+		if n["Node"] == c.node {
-			return true, nil
+			if n["Status"].(string) == "passing" {
 				return true, nil
 			} else {
 				glog.V(2).Infof("Consul Healthcheck returned %s status", n["Status"].(string))
 				return false, nil
 			}
 		}
 	}
 	return false, fmt.Errorf("No healcheck info found for node %s in consul", c.node)
--- a/controller/monitor.go
+++ b/controller/monitor.go
@@ -97,7 +97,7 @@ func NewMonitor(config *c.Config) *MonitorMgr {
 	mon.config = config
 	// add apps defined in config
 	for _, a := range config.Apps {
-		app, err := NewApp(a.Name, a.Vip, a.Monitors, a.Nats)
+		app, err := NewApp(a.Name, a.Vip, a.Monitors, a.Nats, "config")
 		if err != nil {
 			glog.Errorf("Failed to add configured app %s: %v", a.Name, err)
 			continue
@@ -119,7 +119,10 @@ func (m *MonitorMgr) consulMon() {
 			// remove currently running apps that are not discovered in this pass
 			var toRemove []string
 			m.Lock()
-			for name := range m.monitors {
+			for name, mon := range m.monitors {
 				if mon.app.Source != "consul" {
 					continue
 				}
 				var found bool
 				for _, app := range apps {
 					if name == app.Name {
--- a/controller/system.go
+++ b/controller/system.go
@@ -16,6 +16,19 @@ func gateway() (net.IP, error) {
 	return net.ParseIP(strings.TrimSpace(string(out))), nil
 }
 func via(dest net.IP) (net.IP, error) {
 	cmd := fmt.Sprintf(`ip route get %s | grep via | cut -d" " -f3`, dest.String())
 	out, err := exec.Command("bash", "-c", cmd).Output()
 	if err != nil {
 		return nil, fmt.Errorf("Failed to execute command: %s", cmd)
 	}
 	if string(out) == "" {
 		// assume the provided dest is the next hop
 		return dest, nil
 	}
 	return net.ParseIP(strings.TrimSpace(string(out))), nil
 }
 func localAddress(gw net.IP) (net.IP, error) {
 	addrs, err := net.InterfaceAddrs()
 	if err != nil {
--- a/go.mod
+++ b/go.mod
@@ -0,0 +1,37 @@
 module github.com/mayuresh82/gocast
 go 1.12
 require (
 	github.com/armon/go-radix v1.0.0
 	github.com/dgryski/go-farm v0.0.0-20180109070241-2de33835d102
 	github.com/eapache/channels v1.1.0
 	github.com/eapache/queue v1.1.0
 	github.com/fsnotify/fsnotify v1.4.7
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b
 	github.com/golang/protobuf v0.0.0-20181022004443-7be363195599
 	github.com/hashicorp/hcl v1.0.0
 	github.com/influxdata/influxdb v1.6.4
 	github.com/konsorten/go-windows-terminal-sequences v1.0.1
 	github.com/magiconair/properties v1.8.0
 	github.com/mitchellh/mapstructure v1.1.2
 	github.com/osrg/gobgp v0.0.0-20180929145215-329c2d316efe
 	github.com/pelletier/go-toml v1.2.0
 	github.com/satori/go.uuid v0.0.0-20181016184021-8ccf5352a842
 	github.com/sirupsen/logrus v1.1.1
 	github.com/spf13/afero v1.1.2
 	github.com/spf13/cast v1.2.0
 	github.com/spf13/jwalterweatherman v1.0.0
 	github.com/spf13/pflag v1.0.3
 	github.com/spf13/viper v0.0.0-20180930044127-62edee319679
 	github.com/vishvananda/netlink v0.0.0-20181018205019-d3a23fd178f1
 	github.com/vishvananda/netns v0.0.0-20180720170159-13995c7128cc
 	golang.org/x/crypto v0.0.0-20181015023909-0c41d7ab0a0e
 	golang.org/x/net v0.0.0-20181017193950-04a2e542c03f
 	golang.org/x/sys v0.0.0-20181021155630-eda9bb28ed51
 	golang.org/x/text v0.3.0
 	google.golang.org/genproto v0.0.0-20181016170114-94acd270e44e
 	google.golang.org/grpc v1.15.0
 	gopkg.in/tomb.v2 v2.0.0-20161208151619-d5d1b5820637
 	gopkg.in/yaml.v2 v2.2.1
 )
--- a/main.go
+++ b/main.go
@@ -3,9 +3,11 @@ package main
 import (
 	"context"
 	"flag"
 	"github.com/golang/glog"
 	c "github.com/mayuresh82/gocast/config"
 	"github.com/mayuresh82/gocast/controller"
 	"github.com/mayuresh82/gocast/server"
 	log "github.com/sirupsen/logrus"
 	"os"
 	"os/signal"
 	"syscall"
@@ -17,6 +19,9 @@ var (
 func main() {
 	flag.Parse()
 	if glog.V(4) {
 		log.SetLevel(log.DebugLevel)
 	}
 	conf := c.GetConfig(*config)
 	mon := controller.NewMonitor(conf)
 	srv := server.NewServer(conf.Agent.ListenAddr, mon)
--- a/server/server.go
+++ b/server/server.go
@@ -46,7 +46,7 @@ func (s *Server) Serve(ctx context.Context) {
 func (s *Server) registerHandler(w http.ResponseWriter, r *http.Request) {
 	queries := r.URL.Query()
-	app, err := controller.NewApp(queries["name"][0], queries["vip"][0], queries["monitor"], queries["nat"])
+	app, err := controller.NewApp(queries["name"][0], queries["vip"][0], queries["monitor"], queries["nat"], "http")
 	if err != nil {
 		http.Error(w, fmt.Sprintf("Invalid request: %v", err), http.StatusBadRequest)
 		return
--- a/vendor/github.com/armon/go-radix/.gitignore
+++ b/vendor/github.com/armon/go-radix/.gitignore
@@ -0,0 +1,22 @@
 # 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
--- a/vendor/github.com/armon/go-radix/.travis.yml
+++ b/vendor/github.com/armon/go-radix/.travis.yml
@@ -0,0 +1,3 @@
 language: go
 go:
  - tip
--- a/vendor/github.com/armon/go-radix/LICENSE
+++ b/vendor/github.com/armon/go-radix/LICENSE
@@ -0,0 +1,20 @@
 The MIT License (MIT)
 Copyright (c) 2014 Armon Dadgar
 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/armon/go-radix/README.md
+++ b/vendor/github.com/armon/go-radix/README.md
@@ -0,0 +1,38 @@
 go-radix [![Build Status](https://travis-ci.org/armon/go-radix.png)](https://travis-ci.org/armon/go-radix)
 =========
 Provides the `radix` package that implements a [radix tree](http://en.wikipedia.org/wiki/Radix_tree).
 The package only provides a single `Tree` implementation, optimized for sparse nodes.
 As a radix tree, it provides the following:
 * O(k) operations. In many cases, this can be faster than a hash table since
   the hash function is an O(k) operation, and hash tables have very poor cache locality.
 * Minimum / Maximum value lookups
 * Ordered iteration
 For an immutable variant, see [go-immutable-radix](https://github.com/hashicorp/go-immutable-radix).
 Documentation
 =============
 The full documentation is available on [Godoc](http://godoc.org/github.com/armon/go-radix).
 Example
 =======
 Below is a simple example of usage
 ```go
 // Create a tree
 r := radix.New()
 r.Insert("foo", 1)
 r.Insert("bar", 2)
 r.Insert("foobar", 2)
 // Find the longest prefix match
 m, _, _ := r.LongestPrefix("foozip")
 if m != "foo" {
    panic("should be foo")
 }
 ```
--- a/vendor/github.com/armon/go-radix/go.mod
+++ b/vendor/github.com/armon/go-radix/go.mod
@@ -0,0 +1 @@
 module github.com/armon/go-radix
--- a/vendor/github.com/armon/go-radix/radix.go
+++ b/vendor/github.com/armon/go-radix/radix.go
@@ -0,0 +1,540 @@
 package radix
 import (
 	"sort"
 	"strings"
 )
 // WalkFn is used when walking the tree. Takes a
 // key and value, returning if iteration should
 // be terminated.
 type WalkFn func(s string, v interface{}) bool
 // leafNode is used to represent a value
 type leafNode struct {
 	key string
 	val interface{}
 }
 // edge is used to represent an edge node
 type edge struct {
 	label byte
 	node  *node
 }
 type node struct {
 	// leaf is used to store possible leaf
 	leaf *leafNode
 	// prefix is the common prefix we ignore
 	prefix string
 	// Edges should be stored in-order for iteration.
 	// We avoid a fully materialized slice to save memory,
 	// since in most cases we expect to be sparse
 	edges edges
 }
 func (n *node) isLeaf() bool {
 	return n.leaf != nil
 }
 func (n *node) addEdge(e edge) {
 	n.edges = append(n.edges, e)
 	n.edges.Sort()
 }
 func (n *node) updateEdge(label byte, node *node) {
 	num := len(n.edges)
 	idx := sort.Search(num, func(i int) bool {
 		return n.edges[i].label >= label
 	})
 	if idx < num && n.edges[idx].label == label {
 		n.edges[idx].node = node
 		return
 	}
 	panic("replacing missing edge")
 }
 func (n *node) getEdge(label byte) *node {
 	num := len(n.edges)
 	idx := sort.Search(num, func(i int) bool {
 		return n.edges[i].label >= label
 	})
 	if idx < num && n.edges[idx].label == label {
 		return n.edges[idx].node
 	}
 	return nil
 }
 func (n *node) delEdge(label byte) {
 	num := len(n.edges)
 	idx := sort.Search(num, func(i int) bool {
 		return n.edges[i].label >= label
 	})
 	if idx < num && n.edges[idx].label == label {
 		copy(n.edges[idx:], n.edges[idx+1:])
 		n.edges[len(n.edges)-1] = edge{}
 		n.edges = n.edges[:len(n.edges)-1]
 	}
 }
 type edges []edge
 func (e edges) Len() int {
 	return len(e)
 }
 func (e edges) Less(i, j int) bool {
 	return e[i].label < e[j].label
 }
 func (e edges) Swap(i, j int) {
 	e[i], e[j] = e[j], e[i]
 }
 func (e edges) Sort() {
 	sort.Sort(e)
 }
 // Tree implements a radix tree. This can be treated as a
 // Dictionary abstract data type. The main advantage over
 // a standard hash map is prefix-based lookups and
 // ordered iteration,
 type Tree struct {
 	root *node
 	size int
 }
 // New returns an empty Tree
 func New() *Tree {
 	return NewFromMap(nil)
 }
 // NewFromMap returns a new tree containing the keys
 // from an existing map
 func NewFromMap(m map[string]interface{}) *Tree {
 	t := &Tree{root: &node{}}
 	for k, v := range m {
 		t.Insert(k, v)
 	}
 	return t
 }
 // Len is used to return the number of elements in the tree
 func (t *Tree) Len() int {
 	return t.size
 }
 // longestPrefix finds the length of the shared prefix
 // of two strings
 func longestPrefix(k1, k2 string) int {
 	max := len(k1)
 	if l := len(k2); l < max {
 		max = l
 	}
 	var i int
 	for i = 0; i < max; i++ {
 		if k1[i] != k2[i] {
 			break
 		}
 	}
 	return i
 }
 // Insert is used to add a newentry or update
 // an existing entry. Returns if updated.
 func (t *Tree) Insert(s string, v interface{}) (interface{}, bool) {
 	var parent *node
 	n := t.root
 	search := s
 	for {
 		// Handle key exhaution
 		if len(search) == 0 {
 			if n.isLeaf() {
 				old := n.leaf.val
 				n.leaf.val = v
 				return old, true
 			}
 			n.leaf = &leafNode{
 				key: s,
 				val: v,
 			}
 			t.size++
 			return nil, false
 		}
 		// Look for the edge
 		parent = n
 		n = n.getEdge(search[0])
 		// No edge, create one
 		if n == nil {
 			e := edge{
 				label: search[0],
 				node: &node{
 					leaf: &leafNode{
 						key: s,
 						val: v,
 					},
 					prefix: search,
 				},
 			}
 			parent.addEdge(e)
 			t.size++
 			return nil, false
 		}
 		// Determine longest prefix of the search key on match
 		commonPrefix := longestPrefix(search, n.prefix)
 		if commonPrefix == len(n.prefix) {
 			search = search[commonPrefix:]
 			continue
 		}
 		// Split the node
 		t.size++
 		child := &node{
 			prefix: search[:commonPrefix],
 		}
 		parent.updateEdge(search[0], child)
 		// Restore the existing node
 		child.addEdge(edge{
 			label: n.prefix[commonPrefix],
 			node:  n,
 		})
 		n.prefix = n.prefix[commonPrefix:]
 		// Create a new leaf node
 		leaf := &leafNode{
 			key: s,
 			val: v,
 		}
 		// If the new key is a subset, add to to this node
 		search = search[commonPrefix:]
 		if len(search) == 0 {
 			child.leaf = leaf
 			return nil, false
 		}
 		// Create a new edge for the node
 		child.addEdge(edge{
 			label: search[0],
 			node: &node{
 				leaf:   leaf,
 				prefix: search,
 			},
 		})
 		return nil, false
 	}
 }
 // Delete is used to delete a key, returning the previous
 // value and if it was deleted
 func (t *Tree) Delete(s string) (interface{}, bool) {
 	var parent *node
 	var label byte
 	n := t.root
 	search := s
 	for {
 		// Check for key exhaution
 		if len(search) == 0 {
 			if !n.isLeaf() {
 				break
 			}
 			goto DELETE
 		}
 		// Look for an edge
 		parent = n
 		label = search[0]
 		n = n.getEdge(label)
 		if n == nil {
 			break
 		}
 		// Consume the search prefix
 		if strings.HasPrefix(search, n.prefix) {
 			search = search[len(n.prefix):]
 		} else {
 			break
 		}
 	}
 	return nil, false
 DELETE:
 	// Delete the leaf
 	leaf := n.leaf
 	n.leaf = nil
 	t.size--
 	// Check if we should delete this node from the parent
 	if parent != nil && len(n.edges) == 0 {
 		parent.delEdge(label)
 	}
 	// Check if we should merge this node
 	if n != t.root && len(n.edges) == 1 {
 		n.mergeChild()
 	}
 	// Check if we should merge the parent's other child
 	if parent != nil && parent != t.root && len(parent.edges) == 1 && !parent.isLeaf() {
 		parent.mergeChild()
 	}
 	return leaf.val, true
 }
 // DeletePrefix is used to delete the subtree under a prefix
 // Returns how many nodes were deleted
 // Use this to delete large subtrees efficiently
 func (t *Tree) DeletePrefix(s string) int {
 	return t.deletePrefix(nil, t.root, s)
 }
 // delete does a recursive deletion
 func (t *Tree) deletePrefix(parent, n *node, prefix string) int {
 	// Check for key exhaustion
 	if len(prefix) == 0 {
 		// Remove the leaf node
 		subTreeSize := 0
 		//recursively walk from all edges of the node to be deleted
 		recursiveWalk(n, func(s string, v interface{}) bool {
 			subTreeSize++
 			return false
 		})
 		if n.isLeaf() {
 			n.leaf = nil
 		}
 		n.edges = nil // deletes the entire subtree
 		// Check if we should merge the parent's other child
 		if parent != nil && parent != t.root && len(parent.edges) == 1 && !parent.isLeaf() {
 			parent.mergeChild()
 		}
 		t.size -= subTreeSize
 		return subTreeSize
 	}
 	// Look for an edge
 	label := prefix[0]
 	child := n.getEdge(label)
 	if child == nil || (!strings.HasPrefix(child.prefix, prefix) && !strings.HasPrefix(prefix, child.prefix)) {
 		return 0
 	}
 	// Consume the search prefix
 	if len(child.prefix) > len(prefix) {
 		prefix = prefix[len(prefix):]
 	} else {
 		prefix = prefix[len(child.prefix):]
 	}
 	return t.deletePrefix(n, child, prefix)
 }
 func (n *node) mergeChild() {
 	e := n.edges[0]
 	child := e.node
 	n.prefix = n.prefix + child.prefix
 	n.leaf = child.leaf
 	n.edges = child.edges
 }
 // Get is used to lookup a specific key, returning
 // the value and if it was found
 func (t *Tree) Get(s string) (interface{}, bool) {
 	n := t.root
 	search := s
 	for {
 		// Check for key exhaution
 		if len(search) == 0 {
 			if n.isLeaf() {
 				return n.leaf.val, true
 			}
 			break
 		}
 		// Look for an edge
 		n = n.getEdge(search[0])
 		if n == nil {
 			break
 		}
 		// Consume the search prefix
 		if strings.HasPrefix(search, n.prefix) {
 			search = search[len(n.prefix):]
 		} else {
 			break
 		}
 	}
 	return nil, false
 }
 // LongestPrefix is like Get, but instead of an
 // exact match, it will return the longest prefix match.
 func (t *Tree) LongestPrefix(s string) (string, interface{}, bool) {
 	var last *leafNode
 	n := t.root
 	search := s
 	for {
 		// Look for a leaf node
 		if n.isLeaf() {
 			last = n.leaf
 		}
 		// Check for key exhaution
 		if len(search) == 0 {
 			break
 		}
 		// Look for an edge
 		n = n.getEdge(search[0])
 		if n == nil {
 			break
 		}
 		// Consume the search prefix
 		if strings.HasPrefix(search, n.prefix) {
 			search = search[len(n.prefix):]
 		} else {
 			break
 		}
 	}
 	if last != nil {
 		return last.key, last.val, true
 	}
 	return "", nil, false
 }
 // Minimum is used to return the minimum value in the tree
 func (t *Tree) Minimum() (string, interface{}, bool) {
 	n := t.root
 	for {
 		if n.isLeaf() {
 			return n.leaf.key, n.leaf.val, true
 		}
 		if len(n.edges) > 0 {
 			n = n.edges[0].node
 		} else {
 			break
 		}
 	}
 	return "", nil, false
 }
 // Maximum is used to return the maximum value in the tree
 func (t *Tree) Maximum() (string, interface{}, bool) {
 	n := t.root
 	for {
 		if num := len(n.edges); num > 0 {
 			n = n.edges[num-1].node
 			continue
 		}
 		if n.isLeaf() {
 			return n.leaf.key, n.leaf.val, true
 		}
 		break
 	}
 	return "", nil, false
 }
 // Walk is used to walk the tree
 func (t *Tree) Walk(fn WalkFn) {
 	recursiveWalk(t.root, fn)
 }
 // WalkPrefix is used to walk the tree under a prefix
 func (t *Tree) WalkPrefix(prefix string, fn WalkFn) {
 	n := t.root
 	search := prefix
 	for {
 		// Check for key exhaution
 		if len(search) == 0 {
 			recursiveWalk(n, fn)
 			return
 		}
 		// Look for an edge
 		n = n.getEdge(search[0])
 		if n == nil {
 			break
 		}
 		// Consume the search prefix
 		if strings.HasPrefix(search, n.prefix) {
 			search = search[len(n.prefix):]
 		} else if strings.HasPrefix(n.prefix, search) {
 			// Child may be under our search prefix
 			recursiveWalk(n, fn)
 			return
 		} else {
 			break
 		}
 	}
 }
 // WalkPath is used to walk the tree, but only visiting nodes
 // from the root down to a given leaf. Where WalkPrefix walks
 // all the entries *under* the given prefix, this walks the
 // entries *above* the given prefix.
 func (t *Tree) WalkPath(path string, fn WalkFn) {
 	n := t.root
 	search := path
 	for {
 		// Visit the leaf values if any
 		if n.leaf != nil && fn(n.leaf.key, n.leaf.val) {
 			return
 		}
 		// Check for key exhaution
 		if len(search) == 0 {
 			return
 		}
 		// Look for an edge
 		n = n.getEdge(search[0])
 		if n == nil {
 			return
 		}
 		// Consume the search prefix
 		if strings.HasPrefix(search, n.prefix) {
 			search = search[len(n.prefix):]
 		} else {
 			break
 		}
 	}
 }
 // recursiveWalk is used to do a pre-order walk of a node
 // recursively. Returns true if the walk should be aborted
 func recursiveWalk(n *node, fn WalkFn) bool {
 	// Visit the leaf values if any
 	if n.leaf != nil && fn(n.leaf.key, n.leaf.val) {
 		return true
 	}
 	// Recurse on the children
 	for _, e := range n.edges {
 		if recursiveWalk(e.node, fn) {
 			return true
 		}
 	}
 	return false
 }
 // ToMap is used to walk the tree and convert it into a map
 func (t *Tree) ToMap() map[string]interface{} {
 	out := make(map[string]interface{}, t.size)
 	t.Walk(func(k string, v interface{}) bool {
 		out[k] = v
 		return false
 	})
 	return out
 }
--- a/vendor/github.com/dgryski/go-farm/.gitignore
+++ b/vendor/github.com/dgryski/go-farm/.gitignore
@@ -0,0 +1,24 @@
 # 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.*
 *.exe
 *.test
 *.prof
 target
--- a/vendor/github.com/dgryski/go-farm/.travis.yml
+++ b/vendor/github.com/dgryski/go-farm/.travis.yml
@@ -0,0 +1,38 @@
 language: go
 sudo: false
 branches:
  except:
    - release
 branches:
  only:
    - master
    - develop
    - travis
 go:
  - 1.9
  - tip
 matrix:
  allow_failures:
    - go: tip
 before_install:
  - if [ -n "$GH_USER" ]; then git config --global github.user ${GH_USER}; fi;
  - if [ -n "$GH_TOKEN" ]; then git config --global github.token ${GH_TOKEN}; fi;
  - go get github.com/mattn/goveralls
 before_script:
  - make deps
 script:
  - make qa
 after_failure:
  - cat ./target/test/report.xml
 after_success:
  - if [ "$TRAVIS_GO_VERSION" = "1.9" ]; then $HOME/gopath/bin/goveralls -covermode=count -coverprofile=target/report/coverage.out -service=travis-ci; fi;
--- a/vendor/github.com/dgryski/go-farm/LICENSE
+++ b/vendor/github.com/dgryski/go-farm/LICENSE
@@ -0,0 +1,23 @@
 As this is a highly derivative work, I have placed it under the same license as the original implementation:
 Copyright (c) 2014-2017 Damian Gryski
 Copyright (c) 2016-2017 Nicola Asuni - Tecnick.com
 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/dgryski/go-farm/Makefile
+++ b/vendor/github.com/dgryski/go-farm/Makefile
@@ -0,0 +1,203 @@
 # MAKEFILE
 #
 # @author      Nicola Asuni <info@tecnick.com>
 # @link        https://github.com/dgryski/go-farm
 #
 # This file is intended to be executed in a Linux-compatible system.
 # It also assumes that the project has been cloned in the right path under GOPATH:
 # $GOPATH/src/github.com/dgryski/go-farm
 #
 # ------------------------------------------------------------------------------
 # List special make targets that are not associated with files
 .PHONY: help all test format fmtcheck vet lint coverage cyclo ineffassign misspell structcheck varcheck errcheck gosimple astscan qa deps clean nuke
 # Use bash as shell (Note: Ubuntu now uses dash which doesn't support PIPESTATUS).
 SHELL=/bin/bash
 # CVS path (path to the parent dir containing the project)
 CVSPATH=github.com/dgryski
 # Project owner
 OWNER=dgryski
 # Project vendor
 VENDOR=dgryski
 # Project name
 PROJECT=go-farm
 # Project version
 VERSION=$(shell cat VERSION)
 # Name of RPM or DEB package
 PKGNAME=${VENDOR}-${PROJECT}
 # Current directory
 CURRENTDIR=$(shell pwd)
 # GO lang path
 ifneq ($(GOPATH),)
 	ifeq ($(findstring $(GOPATH),$(CURRENTDIR)),)
 		# the defined GOPATH is not valid
 		GOPATH=
 	endif
 endif
 ifeq ($(GOPATH),)
 	# extract the GOPATH
 	GOPATH=$(firstword $(subst /src/, ,$(CURRENTDIR)))
 endif
 # --- MAKE TARGETS ---
 # Display general help about this command
 help:
 	@echo ""
 	@echo "$(PROJECT) Makefile."
 	@echo "GOPATH=$(GOPATH)"
 	@echo "The following commands are available:"
 	@echo ""
 	@echo "    make qa          : Run all the tests"
 	@echo "    make test        : Run the unit tests"
 	@echo ""
 	@echo "    make format      : Format the source code"
 	@echo "    make fmtcheck    : Check if the source code has been formatted"
 	@echo "    make vet         : Check for suspicious constructs"
 	@echo "    make lint        : Check for style errors"
 	@echo "    make coverage    : Generate the coverage report"
 	@echo "    make cyclo       : Generate the cyclomatic complexity report"
 	@echo "    make ineffassign : Detect ineffectual assignments"
 	@echo "    make misspell    : Detect commonly misspelled words in source files"
 	@echo "    make structcheck : Find unused struct fields"
 	@echo "    make varcheck    : Find unused global variables and constants"
 	@echo "    make errcheck    : Check that error return values are used"
 	@echo "    make gosimple    : Suggest code simplifications"
 	@echo "    make astscan     : GO AST scanner"
 	@echo ""
 	@echo "    make docs        : Generate source code documentation"
 	@echo ""
 	@echo "    make deps        : Get the dependencies"
 	@echo "    make clean       : Remove any build artifact"
 	@echo "    make nuke        : Deletes any intermediate file"
 	@echo ""
 # Alias for help target
 all: help
 # Run the unit tests
 test:
 	@mkdir -p target/test
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) \
 	go test \
 	-covermode=atomic \
 	-bench=. \
 	-race \
 	-cpuprofile=target/report/cpu.out \
 	-memprofile=target/report/mem.out \
 	-mutexprofile=target/report/mutex.out \
 	-coverprofile=target/report/coverage.out \
 	-v ./... | \
 	tee >(PATH=$(GOPATH)/bin:$(PATH) go-junit-report > target/test/report.xml); \
 	test $${PIPESTATUS[0]} -eq 0
 # Format the source code
 format:
 	@find . -type f -name "*.go" -exec gofmt -s -w {} \;
 # Check if the source code has been formatted
 fmtcheck:
 	@mkdir -p target
 	@find . -type f -name "*.go" -exec gofmt -s -d {} \; | tee target/format.diff
 	@test ! -s target/format.diff || { echo "ERROR: the source code has not been formatted - please use 'make format' or 'gofmt'"; exit 1; }
 # Check for syntax errors
 vet:
 	GOPATH=$(GOPATH) go vet .
 # Check for style errors
 lint:
 	GOPATH=$(GOPATH) PATH=$(GOPATH)/bin:$(PATH) golint .
 # Generate the coverage report
 coverage:
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) \
 	go tool cover -html=target/report/coverage.out -o target/report/coverage.html
 # Report cyclomatic complexity
 cyclo:
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) gocyclo -avg ./ | tee target/report/cyclo.txt ; test $${PIPESTATUS[0]} -eq 0
 # Detect ineffectual assignments
 ineffassign:
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) ineffassign ./ | tee target/report/ineffassign.txt ; test $${PIPESTATUS[0]} -eq 0
 # Detect commonly misspelled words in source files
 misspell:
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) misspell -error ./  | tee target/report/misspell.txt ; test $${PIPESTATUS[0]} -eq 0
 # Find unused struct fields
 structcheck:
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) structcheck -a ./  | tee target/report/structcheck.txt
 # Find unused global variables and constants
 varcheck:
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) varcheck -e ./  | tee target/report/varcheck.txt
 # Check that error return values are used
 errcheck:
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) errcheck ./  | tee target/report/errcheck.txt
 # Suggest code simplifications
 gosimple:
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) gosimple ./  | tee target/report/gosimple.txt
 # AST scanner
 astscan:
 	@mkdir -p target/report
 	GOPATH=$(GOPATH) gas .//*.go | tee target/report/astscan.txt
 # Generate source docs
 docs:
 	@mkdir -p target/docs
 	nohup sh -c 'GOPATH=$(GOPATH) godoc -http=127.0.0.1:6060' > target/godoc_server.log 2>&1 &
 	wget --directory-prefix=target/docs/ --execute robots=off --retry-connrefused --recursive --no-parent --adjust-extension --page-requisites --convert-links http://127.0.0.1:6060/pkg/github.com/${VENDOR}/${PROJECT}/ ; kill -9 `lsof -ti :6060`
 	@echo '<html><head><meta http-equiv="refresh" content="0;./127.0.0.1:6060/pkg/'${CVSPATH}'/'${PROJECT}'/index.html"/></head><a href="./127.0.0.1:6060/pkg/'${CVSPATH}'/'${PROJECT}'/index.html">'${PKGNAME}' Documentation ...</a></html>' > target/docs/index.html
 # Alias to run all quality-assurance checks
 qa: fmtcheck test vet lint coverage cyclo ineffassign misspell structcheck varcheck errcheck gosimple astscan
 # --- INSTALL ---
 # Get the dependencies
 deps:
 	GOPATH=$(GOPATH) go get ./...
 	GOPATH=$(GOPATH) go get github.com/golang/lint/golint
 	GOPATH=$(GOPATH) go get github.com/jstemmer/go-junit-report
 	GOPATH=$(GOPATH) go get github.com/axw/gocov/gocov
 	GOPATH=$(GOPATH) go get github.com/fzipp/gocyclo
 	GOPATH=$(GOPATH) go get github.com/gordonklaus/ineffassign
 	GOPATH=$(GOPATH) go get github.com/client9/misspell/cmd/misspell
 	GOPATH=$(GOPATH) go get github.com/opennota/check/cmd/structcheck
 	GOPATH=$(GOPATH) go get github.com/opennota/check/cmd/varcheck
 	GOPATH=$(GOPATH) go get github.com/kisielk/errcheck
 	GOPATH=$(GOPATH) go get honnef.co/go/tools/cmd/gosimple
 	GOPATH=$(GOPATH) go get github.com/GoASTScanner/gas
 # Remove any build artifact
 clean:
 	GOPATH=$(GOPATH) go clean ./...
 # Deletes any intermediate file
 nuke:
 	rm -rf ./target
 	GOPATH=$(GOPATH) go clean -i ./...
--- a/vendor/github.com/dgryski/go-farm/README.md
+++ b/vendor/github.com/dgryski/go-farm/README.md
@@ -0,0 +1,41 @@
 # go-farm
 *Google's FarmHash hash functions implemented in Go*
 [![Master Branch](https://img.shields.io/badge/-master:-gray.svg)](https://github.com/dgryski/go-farm/tree/master)
 [![Master Build Status](https://secure.travis-ci.org/dgryski/go-farm.png?branch=master)](https://travis-ci.org/dgryski/go-farm?branch=master)
 [![Master Coverage Status](https://coveralls.io/repos/dgryski/go-farm/badge.svg?branch=master&service=github)](https://coveralls.io/github/dgryski/go-farm?branch=master)
 [![Go Report Card](https://goreportcard.com/badge/github.com/dgryski/go-farm)](https://goreportcard.com/report/github.com/dgryski/go-farm)
 [![GoDoc](https://godoc.org/github.com/dgryski/go-farm?status.svg)](http://godoc.org/github.com/dgryski/go-farm)
 ## Description
 FarmHash, a family of hash functions.
 This is a (mechanical) translation of the non-SSE4/non-AESNI hash functions from Google's FarmHash (https://github.com/google/farmhash).
 FarmHash provides hash functions for strings and other data.
 The functions mix the input bits thoroughly but are not suitable for cryptography.
 All members of the FarmHash family were designed with heavy reliance on previous work by Jyrki Alakuijala, Austin Appleby, Bob Jenkins, and others.
 For more information please consult https://github.com/google/farmhash
 ## Getting started
 This application is written in Go language, please refer to the guides in https://golang.org for getting started.
 This project include a Makefile that allows you to test and build the project with simple commands.
 To see all available options:
 ```bash
 make help
 ```
 ## Running all tests
 Before committing the code, please check if it passes all tests using
 ```bash
 make qa
 ```
--- a/vendor/github.com/dgryski/go-farm/VERSION
+++ b/vendor/github.com/dgryski/go-farm/VERSION
@@ -0,0 +1 @@
 2.0.1
--- a/vendor/github.com/dgryski/go-farm/basics.go
+++ b/vendor/github.com/dgryski/go-farm/basics.go
@@ -0,0 +1,30 @@
 package farm
 // Some primes between 2^63 and 2^64 for various uses.
 const k0 uint64 = 0xc3a5c85c97cb3127
 const k1 uint64 = 0xb492b66fbe98f273
 const k2 uint64 = 0x9ae16a3b2f90404f
 // Magic numbers for 32-bit hashing.  Copied from Murmur3.
 const c1 uint32 = 0xcc9e2d51
 const c2 uint32 = 0x1b873593
 // A 32-bit to 32-bit integer hash copied from Murmur3.
 func fmix(h uint32) uint32 {
 	h ^= h >> 16
 	h *= 0x85ebca6b
 	h ^= h >> 13
 	h *= 0xc2b2ae35
 	h ^= h >> 16
 	return h
 }
 func mur(a, h uint32) uint32 {
 	// Helper from Murmur3 for combining two 32-bit values.
 	a *= c1
 	a = rotate32(a, 17)
 	a *= c2
 	h ^= a
 	h = rotate32(h, 19)
 	return h*5 + 0xe6546b64
 }
--- a/vendor/github.com/dgryski/go-farm/farmhashcc.go
+++ b/vendor/github.com/dgryski/go-farm/farmhashcc.go
@@ -0,0 +1,199 @@
 package farm
 // This file provides a 32-bit hash equivalent to CityHash32 (v1.1.1)
 // and a 128-bit hash equivalent to CityHash128 (v1.1.1).  It also provides
 // a seeded 32-bit hash function similar to CityHash32.
 func hash32Len13to24Seed(s []byte, seed uint32) uint32 {
 	slen := len(s)
 	a := fetch32(s, -4+(slen>>1))
 	b := fetch32(s, 4)
 	c := fetch32(s, slen-8)
 	d := fetch32(s, (slen >> 1))
 	e := fetch32(s, 0)
 	f := fetch32(s, slen-4)
 	h := d*c1 + uint32(slen) + seed
 	a = rotate32(a, 12) + f
 	h = mur(c, h) + a
 	a = rotate32(a, 3) + c
 	h = mur(e, h) + a
 	a = rotate32(a+f, 12) + d
 	h = mur(b^seed, h) + a
 	return fmix(h)
 }
 func hash32Len0to4(s []byte, seed uint32) uint32 {
 	slen := len(s)
 	b := seed
 	c := uint32(9)
 	for i := 0; i < slen; i++ {
 		v := int8(s[i])
 		b = (b * c1) + uint32(v)
 		c ^= b
 	}
 	return fmix(mur(b, mur(uint32(slen), c)))
 }
 func hash128to64(x uint128) uint64 {
 	// Murmur-inspired hashing.
 	const mul uint64 = 0x9ddfea08eb382d69
 	a := (x.lo ^ x.hi) * mul
 	a ^= (a >> 47)
 	b := (x.hi ^ a) * mul
 	b ^= (b >> 47)
 	b *= mul
 	return b
 }
 type uint128 struct {
 	lo uint64
 	hi uint64
 }
 // A subroutine for CityHash128().  Returns a decent 128-bit hash for strings
 // of any length representable in signed long.  Based on City and Murmur.
 func cityMurmur(s []byte, seed uint128) uint128 {
 	slen := len(s)
 	a := seed.lo
 	b := seed.hi
 	var c uint64
 	var d uint64
 	l := slen - 16
 	if l <= 0 { // len <= 16
 		a = shiftMix(a*k1) * k1
 		c = b*k1 + hashLen0to16(s)
 		if slen >= 8 {
 			d = shiftMix(a + fetch64(s, 0))
 		} else {
 			d = shiftMix(a + c)
 		}
 	} else { // len > 16
 		c = hashLen16(fetch64(s, slen-8)+k1, a)
 		d = hashLen16(b+uint64(slen), c+fetch64(s, slen-16))
 		a += d
 		for {
 			a ^= shiftMix(fetch64(s, 0)*k1) * k1
 			a *= k1
 			b ^= a
 			c ^= shiftMix(fetch64(s, 8)*k1) * k1
 			c *= k1
 			d ^= c
 			s = s[16:]
 			l -= 16
 			if l <= 0 {
 				break
 			}
 		}
 	}
 	a = hashLen16(a, c)
 	b = hashLen16(d, b)
 	return uint128{a ^ b, hashLen16(b, a)}
 }
 func cityHash128WithSeed(s []byte, seed uint128) uint128 {
 	slen := len(s)
 	if slen < 128 {
 		return cityMurmur(s, seed)
 	}
 	endIdx := ((slen - 1) / 128) * 128
 	lastBlockIdx := endIdx + ((slen - 1) & 127) - 127
 	last := s[lastBlockIdx:]
 	// We expect len >= 128 to be the common case.  Keep 56 bytes of state:
 	// v, w, x, y, and z.
 	var v1, v2 uint64
 	var w1, w2 uint64
 	x := seed.lo
 	y := seed.hi
 	z := uint64(slen) * k1
 	v1 = rotate64(y^k1, 49)*k1 + fetch64(s, 0)
 	v2 = rotate64(v1, 42)*k1 + fetch64(s, 8)
 	w1 = rotate64(y+z, 35)*k1 + x
 	w2 = rotate64(x+fetch64(s, 88), 53) * k1
 	// This is the same inner loop as CityHash64(), manually unrolled.
 	for {
 		x = rotate64(x+y+v1+fetch64(s, 8), 37) * k1
 		y = rotate64(y+v2+fetch64(s, 48), 42) * k1
 		x ^= w2
 		y += v1 + fetch64(s, 40)
 		z = rotate64(z+w1, 33) * k1
 		v1, v2 = weakHashLen32WithSeeds(s, v2*k1, x+w1)
 		w1, w2 = weakHashLen32WithSeeds(s[32:], z+w2, y+fetch64(s, 16))
 		z, x = x, z
 		s = s[64:]
 		x = rotate64(x+y+v1+fetch64(s, 8), 37) * k1
 		y = rotate64(y+v2+fetch64(s, 48), 42) * k1
 		x ^= w2
 		y += v1 + fetch64(s, 40)
 		z = rotate64(z+w1, 33) * k1
 		v1, v2 = weakHashLen32WithSeeds(s, v2*k1, x+w1)
 		w1, w2 = weakHashLen32WithSeeds(s[32:], z+w2, y+fetch64(s, 16))
 		z, x = x, z
 		s = s[64:]
 		slen -= 128
 		if slen < 128 {
 			break
 		}
 	}
 	x += rotate64(v1+z, 49) * k0
 	y = y*k0 + rotate64(w2, 37)
 	z = z*k0 + rotate64(w1, 27)
 	w1 *= 9
 	v1 *= k0
 	// If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
 	for tailDone := 0; tailDone < slen; {
 		tailDone += 32
 		y = rotate64(x+y, 42)*k0 + v2
 		w1 += fetch64(last, 128-tailDone+16)
 		x = x*k0 + w1
 		z += w2 + fetch64(last, 128-tailDone)
 		w2 += v1
 		v1, v2 = weakHashLen32WithSeeds(last[128-tailDone:], v1+z, v2)
 		v1 *= k0
 	}
 	// At this point our 56 bytes of state should contain more than
 	// enough information for a strong 128-bit hash.  We use two
 	// different 56-byte-to-8-byte hashes to get a 16-byte final result.
 	x = hashLen16(x, v1)
 	y = hashLen16(y+z, w1)
 	return uint128{hashLen16(x+v2, w2) + y,
 		hashLen16(x+w2, y+v2)}
 }
 func cityHash128(s []byte) uint128 {
 	slen := len(s)
 	if slen >= 16 {
 		return cityHash128WithSeed(s[16:], uint128{fetch64(s, 0), fetch64(s, 8) + k0})
 	}
 	return cityHash128WithSeed(s, uint128{k0, k1})
 }
 // Fingerprint128 is a 128-bit fingerprint function for byte-slices
 func Fingerprint128(s []byte) (lo, hi uint64) {
 	h := cityHash128(s)
 	return h.lo, h.hi
 }
 // Fingerprint64 is a 64-bit fingerprint function for byte-slices
 func Fingerprint64(s []byte) uint64 {
 	return naHash64(s)
 }
 // Fingerprint32 is a 32-bit fingerprint function for byte-slices
 func Fingerprint32(s []byte) uint32 {
 	return Hash32(s)
 }
 // Hash128 is a 128-bit hash function for byte-slices
 func Hash128(s []byte) (lo, hi uint64) {
 	return Fingerprint128(s)
 }
 // Hash128WithSeed is a 128-bit hash function for byte-slices and a 128-bit seed
 func Hash128WithSeed(s []byte, seed0, seed1 uint64) (lo, hi uint64) {
 	h := cityHash128WithSeed(s, uint128{seed0, seed1})
 	return h.lo, h.hi
 }
--- a/vendor/github.com/dgryski/go-farm/farmhashmk.go
+++ b/vendor/github.com/dgryski/go-farm/farmhashmk.go
@@ -0,0 +1,102 @@
 package farm
 func hash32Len5to12(s []byte, seed uint32) uint32 {
 	slen := len(s)
 	a := uint32(len(s))
 	b := uint32(len(s) * 5)
 	c := uint32(9)
 	d := b + seed
 	a += fetch32(s, 0)
 	b += fetch32(s, slen-4)
 	c += fetch32(s, ((slen >> 1) & 4))
 	return fmix(seed ^ mur(c, mur(b, mur(a, d))))
 }
 // Hash32 hashes a byte slice and returns a uint32 hash value
 func Hash32(s []byte) uint32 {
 	slen := len(s)
 	if slen <= 24 {
 		if slen <= 12 {
 			if slen <= 4 {
 				return hash32Len0to4(s, 0)
 			}
 			return hash32Len5to12(s, 0)
 		}
 		return hash32Len13to24Seed(s, 0)
 	}
 	// len > 24
 	h := uint32(slen)
 	g := c1 * uint32(slen)
 	f := g
 	a0 := rotate32(fetch32(s, slen-4)*c1, 17) * c2
 	a1 := rotate32(fetch32(s, slen-8)*c1, 17) * c2
 	a2 := rotate32(fetch32(s, slen-16)*c1, 17) * c2
 	a3 := rotate32(fetch32(s, slen-12)*c1, 17) * c2
 	a4 := rotate32(fetch32(s, slen-20)*c1, 17) * c2
 	h ^= a0
 	h = rotate32(h, 19)
 	h = h*5 + 0xe6546b64
 	h ^= a2
 	h = rotate32(h, 19)
 	h = h*5 + 0xe6546b64
 	g ^= a1
 	g = rotate32(g, 19)
 	g = g*5 + 0xe6546b64
 	g ^= a3
 	g = rotate32(g, 19)
 	g = g*5 + 0xe6546b64
 	f += a4
 	f = rotate32(f, 19) + 113
 	iters := (slen - 1) / 20
 	for {
 		a := fetch32(s, 0)
 		b := fetch32(s, 4)
 		c := fetch32(s, 8)
 		d := fetch32(s, 12)
 		e := fetch32(s, 16)
 		h += a
 		g += b
 		f += c
 		h = mur(d, h) + e
 		g = mur(c, g) + a
 		f = mur(b+e*c1, f) + d
 		f += g
 		g += f
 		s = s[20:]
 		iters--
 		if iters == 0 {
 			break
 		}
 	}
 	g = rotate32(g, 11) * c1
 	g = rotate32(g, 17) * c1
 	f = rotate32(f, 11) * c1
 	f = rotate32(f, 17) * c1
 	h = rotate32(h+g, 19)
 	h = h*5 + 0xe6546b64
 	h = rotate32(h, 17) * c1
 	h = rotate32(h+f, 19)
 	h = h*5 + 0xe6546b64
 	h = rotate32(h, 17) * c1
 	return h
 }
 // Hash32WithSeed hashes a byte slice and a uint32 seed and returns a uint32 hash value
 func Hash32WithSeed(s []byte, seed uint32) uint32 {
 	slen := len(s)
 	if slen <= 24 {
 		if slen >= 13 {
 			return hash32Len13to24Seed(s, seed*c1)
 		}
 		if slen >= 5 {
 			return hash32Len5to12(s, seed)
 		}
 		return hash32Len0to4(s, seed)
 	}
 	h := hash32Len13to24Seed(s[:24], seed^uint32(slen))
 	return mur(Hash32(s[24:])+seed, h)
 }
--- a/vendor/github.com/dgryski/go-farm/farmhashna.go
+++ b/vendor/github.com/dgryski/go-farm/farmhashna.go
@@ -0,0 +1,156 @@
 package farm
 func shiftMix(val uint64) uint64 {
 	return val ^ (val >> 47)
 }
 func hashLen16(u, v uint64) uint64 {
 	return hash128to64(uint128{u, v})
 }
 func hashLen16Mul(u, v, mul uint64) uint64 {
 	// Murmur-inspired hashing.
 	a := (u ^ v) * mul
 	a ^= (a >> 47)
 	b := (v ^ a) * mul
 	b ^= (b >> 47)
 	b *= mul
 	return b
 }
 func hashLen0to16(s []byte) uint64 {
 	slen := uint64(len(s))
 	if slen >= 8 {
 		mul := k2 + slen*2
 		a := fetch64(s, 0) + k2
 		b := fetch64(s, int(slen-8))
 		c := rotate64(b, 37)*mul + a
 		d := (rotate64(a, 25) + b) * mul
 		return hashLen16Mul(c, d, mul)
 	}
 	if slen >= 4 {
 		mul := k2 + slen*2
 		a := fetch32(s, 0)
 		return hashLen16Mul(slen+(uint64(a)<<3), uint64(fetch32(s, int(slen-4))), mul)
 	}
 	if slen > 0 {
 		a := s[0]
 		b := s[slen>>1]
 		c := s[slen-1]
 		y := uint32(a) + (uint32(b) << 8)
 		z := uint32(slen) + (uint32(c) << 2)
 		return shiftMix(uint64(y)*k2^uint64(z)*k0) * k2
 	}
 	return k2
 }
 // This probably works well for 16-byte strings as well, but it may be overkill
 // in that case.
 func hashLen17to32(s []byte) uint64 {
 	slen := len(s)
 	mul := k2 + uint64(slen*2)
 	a := fetch64(s, 0) * k1
 	b := fetch64(s, 8)
 	c := fetch64(s, slen-8) * mul
 	d := fetch64(s, slen-16) * k2
 	return hashLen16Mul(rotate64(a+b, 43)+rotate64(c, 30)+d, a+rotate64(b+k2, 18)+c, mul)
 }
 // Return a 16-byte hash for 48 bytes.  Quick and dirty.
 // Callers do best to use "random-looking" values for a and b.
 func weakHashLen32WithSeedsWords(w, x, y, z, a, b uint64) (uint64, uint64) {
 	a += w
 	b = rotate64(b+a+z, 21)
 	c := a
 	a += x
 	a += y
 	b += rotate64(a, 44)
 	return a + z, b + c
 }
 // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
 func weakHashLen32WithSeeds(s []byte, a, b uint64) (uint64, uint64) {
 	return weakHashLen32WithSeedsWords(fetch64(s, 0),
 		fetch64(s, 8),
 		fetch64(s, 16),
 		fetch64(s, 24),
 		a,
 		b)
 }
 // Return an 8-byte hash for 33 to 64 bytes.
 func hashLen33to64(s []byte) uint64 {
 	slen := len(s)
 	mul := k2 + uint64(slen)*2
 	a := fetch64(s, 0) * k2
 	b := fetch64(s, 8)
 	c := fetch64(s, slen-8) * mul
 	d := fetch64(s, slen-16) * k2
 	y := rotate64(a+b, 43) + rotate64(c, 30) + d
 	z := hashLen16Mul(y, a+rotate64(b+k2, 18)+c, mul)
 	e := fetch64(s, 16) * mul
 	f := fetch64(s, 24)
 	g := (y + fetch64(s, slen-32)) * mul
 	h := (z + fetch64(s, slen-24)) * mul
 	return hashLen16Mul(rotate64(e+f, 43)+rotate64(g, 30)+h, e+rotate64(f+a, 18)+g, mul)
 }
 func naHash64(s []byte) uint64 {
 	slen := len(s)
 	var seed uint64 = 81
 	if slen <= 32 {
 		if slen <= 16 {
 			return hashLen0to16(s)
 		}
 		return hashLen17to32(s)
 	}
 	if slen <= 64 {
 		return hashLen33to64(s)
 	}
 	// For strings over 64 bytes we loop.
 	// Internal state consists of 56 bytes: v, w, x, y, and z.
 	v := uint128{0, 0}
 	w := uint128{0, 0}
 	x := seed*k2 + fetch64(s, 0)
 	y := seed*k1 + 113
 	z := shiftMix(y*k2+113) * k2
 	// Set end so that after the loop we have 1 to 64 bytes left to process.
 	endIdx := ((slen - 1) / 64) * 64
 	last64Idx := endIdx + ((slen - 1) & 63) - 63
 	last64 := s[last64Idx:]
 	for len(s) > 64 {
 		x = rotate64(x+y+v.lo+fetch64(s, 8), 37) * k1
 		y = rotate64(y+v.hi+fetch64(s, 48), 42) * k1
 		x ^= w.hi
 		y += v.lo + fetch64(s, 40)
 		z = rotate64(z+w.lo, 33) * k1
 		v.lo, v.hi = weakHashLen32WithSeeds(s, v.hi*k1, x+w.lo)
 		w.lo, w.hi = weakHashLen32WithSeeds(s[32:], z+w.hi, y+fetch64(s, 16))
 		x, z = z, x
 		s = s[64:]
 	}
 	mul := k1 + ((z & 0xff) << 1)
 	// Make s point to the last 64 bytes of input.
 	s = last64
 	w.lo += (uint64(slen-1) & 63)
 	v.lo += w.lo
 	w.lo += v.lo
 	x = rotate64(x+y+v.lo+fetch64(s, 8), 37) * mul
 	y = rotate64(y+v.hi+fetch64(s, 48), 42) * mul
 	x ^= w.hi * 9
 	y += v.lo*9 + fetch64(s, 40)
 	z = rotate64(z+w.lo, 33) * mul
 	v.lo, v.hi = weakHashLen32WithSeeds(s, v.hi*mul, x+w.lo)
 	w.lo, w.hi = weakHashLen32WithSeeds(s[32:], z+w.hi, y+fetch64(s, 16))
 	x, z = z, x
 	return hashLen16Mul(hashLen16Mul(v.lo, w.lo, mul)+shiftMix(y)*k0+z, hashLen16Mul(v.hi, w.hi, mul)+x, mul)
 }
 func naHash64WithSeed(s []byte, seed uint64) uint64 {
 	return naHash64WithSeeds(s, k2, seed)
 }
 func naHash64WithSeeds(s []byte, seed0, seed1 uint64) uint64 {
 	return hashLen16(naHash64(s)-seed0, seed1)
 }
--- a/vendor/github.com/dgryski/go-farm/farmhashuo.go
+++ b/vendor/github.com/dgryski/go-farm/farmhashuo.go
@@ -0,0 +1,117 @@
 package farm
 func uoH(x, y, mul uint64, r uint) uint64 {
 	a := (x ^ y) * mul
 	a ^= (a >> 47)
 	b := (y ^ a) * mul
 	return rotate64(b, r) * mul
 }
 // Hash64WithSeeds hashes a byte slice and two uint64 seeds and returns a uint64 hash value
 func Hash64WithSeeds(s []byte, seed0, seed1 uint64) uint64 {
 	slen := len(s)
 	if slen <= 64 {
 		return naHash64WithSeeds(s, seed0, seed1)
 	}
 	// For strings over 64 bytes we loop.
 	// Internal state consists of 64 bytes: u, v, w, x, y, and z.
 	x := seed0
 	y := seed1*k2 + 113
 	z := shiftMix(y*k2) * k2
 	v := uint128{seed0, seed1}
 	var w uint128
 	u := x - z
 	x *= k2
 	mul := k2 + (u & 0x82)
 	// Set end so that after the loop we have 1 to 64 bytes left to process.
 	endIdx := ((slen - 1) / 64) * 64
 	last64Idx := endIdx + ((slen - 1) & 63) - 63
 	last64 := s[last64Idx:]
 	for len(s) > 64 {
 		a0 := fetch64(s, 0)
 		a1 := fetch64(s, 8)
 		a2 := fetch64(s, 16)
 		a3 := fetch64(s, 24)
 		a4 := fetch64(s, 32)
 		a5 := fetch64(s, 40)
 		a6 := fetch64(s, 48)
 		a7 := fetch64(s, 56)
 		x += a0 + a1
 		y += a2
 		z += a3
 		v.lo += a4
 		v.hi += a5 + a1
 		w.lo += a6
 		w.hi += a7
 		x = rotate64(x, 26)
 		x *= 9
 		y = rotate64(y, 29)
 		z *= mul
 		v.lo = rotate64(v.lo, 33)
 		v.hi = rotate64(v.hi, 30)
 		w.lo ^= x
 		w.lo *= 9
 		z = rotate64(z, 32)
 		z += w.hi
 		w.hi += z
 		z *= 9
 		u, y = y, u
 		z += a0 + a6
 		v.lo += a2
 		v.hi += a3
 		w.lo += a4
 		w.hi += a5 + a6
 		x += a1
 		y += a7
 		y += v.lo
 		v.lo += x - y
 		v.hi += w.lo
 		w.lo += v.hi
 		w.hi += x - y
 		x += w.hi
 		w.hi = rotate64(w.hi, 34)
 		u, z = z, u
 		s = s[64:]
 	}
 	// Make s point to the last 64 bytes of input.
 	s = last64
 	u *= 9
 	v.hi = rotate64(v.hi, 28)
 	v.lo = rotate64(v.lo, 20)
 	w.lo += (uint64(slen-1) & 63)
 	u += y
 	y += u
 	x = rotate64(y-x+v.lo+fetch64(s, 8), 37) * mul
 	y = rotate64(y^v.hi^fetch64(s, 48), 42) * mul
 	x ^= w.hi * 9
 	y += v.lo + fetch64(s, 40)
 	z = rotate64(z+w.lo, 33) * mul
 	v.lo, v.hi = weakHashLen32WithSeeds(s, v.hi*mul, x+w.lo)
 	w.lo, w.hi = weakHashLen32WithSeeds(s[32:], z+w.hi, y+fetch64(s, 16))
 	return uoH(hashLen16Mul(v.lo+x, w.lo^y, mul)+z-u,
 		uoH(v.hi+y, w.hi+z, k2, 30)^x,
 		k2,
 		31)
 }
 // Hash64WithSeed hashes a byte slice and a uint64 seed and returns a uint64 hash value
 func Hash64WithSeed(s []byte, seed uint64) uint64 {
 	if len(s) <= 64 {
 		return naHash64WithSeed(s, seed)
 	}
 	return Hash64WithSeeds(s, 0, seed)
 }
 // Hash64 hashes a byte slice and returns a uint64 hash value
 func Hash64(s []byte) uint64 {
 	if len(s) <= 64 {
 		return naHash64(s)
 	}
 	return Hash64WithSeeds(s, 81, 0)
 }
--- a/vendor/github.com/dgryski/go-farm/platform.go
+++ b/vendor/github.com/dgryski/go-farm/platform.go
@@ -0,0 +1,18 @@
 package farm
 func rotate32(val uint32, shift uint) uint32 {
 	return ((val >> shift) | (val << (32 - shift)))
 }
 func rotate64(val uint64, shift uint) uint64 {
 	return ((val >> shift) | (val << (64 - shift)))
 }
 func fetch32(s []byte, idx int) uint32 {
 	return uint32(s[idx+0]) | uint32(s[idx+1])<<8 | uint32(s[idx+2])<<16 | uint32(s[idx+3])<<24
 }
 func fetch64(s []byte, idx int) uint64 {
 	return uint64(s[idx+0]) | uint64(s[idx+1])<<8 | uint64(s[idx+2])<<16 | uint64(s[idx+3])<<24 |
 		uint64(s[idx+4])<<32 | uint64(s[idx+5])<<40 | uint64(s[idx+6])<<48 | uint64(s[idx+7])<<56
 }
--- a/vendor/github.com/eapache/channels/.gitignore
+++ b/vendor/github.com/eapache/channels/.gitignore
@@ -0,0 +1,22 @@
 # 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
--- a/vendor/github.com/eapache/channels/.travis.yml
+++ b/vendor/github.com/eapache/channels/.travis.yml
@@ -0,0 +1,11 @@
 language: go
 sudo: false
 script: go test -v -race -timeout 10s ./...
 go:
    - 1.1
    - 1.2
    - 1.3
    - 1.4
    - 1.5
--- a/vendor/github.com/eapache/channels/CHANGELOG.md
+++ b/vendor/github.com/eapache/channels/CHANGELOG.md
@@ -0,0 +1,17 @@
 # Changelog
 #### Version 1.1.0 (2015-11-22)
 Bug Fixes:
 - The `Len()` and `Cap()` methods on several implementations were racy
   ([#18](https://github.com/eapache/channels/issues/18)).
 Note: Fixing the above issue led to a fairly substantial performance hit
 (anywhere from 10-25% in benchmarks depending on use case) and involved fairly
 major refactoring, which is why this is being released as v1.1.0 instead
 of v1.0.1.
 #### Version 1.0.0 (2015-01-24)
 Version 1.0.0 is the first tagged release. All core functionality was available
 at this point.
--- a/vendor/github.com/eapache/channels/LICENSE
+++ b/vendor/github.com/eapache/channels/LICENSE
@@ -0,0 +1,20 @@
 The MIT License (MIT)
 Copyright (c) 2013 Evan Huus
 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/eapache/channels/README.md
+++ b/vendor/github.com/eapache/channels/README.md
@@ -0,0 +1,27 @@
 channels
 ========
 [![Build Status](https://travis-ci.org/eapache/channels.svg?branch=master)](https://travis-ci.org/eapache/channels)
 [![GoDoc](https://godoc.org/github.com/eapache/channels?status.png)](https://godoc.org/github.com/eapache/channels)
 [![Code of Conduct](https://img.shields.io/badge/code%20of%20conduct-active-blue.svg)](https://eapache.github.io/conduct.html)
 A collection of helper functions and special types for working with and
 extending [Go](https://golang.org/)'s existing channels. Due to limitations
 of Go's type system, importing this library directly is often not practical for
 production code. It serves equally well, however, as a reference guide and
 template for implementing many common idioms; if you use it in this way I would
 appreciate the inclusion of some sort of credit in the resulting code.
 See https://godoc.org/github.com/eapache/channels for full documentation or
 https://gopkg.in/eapache/channels.v1 for a versioned import path.
 Requires Go version 1.1 or later, as certain necessary elements of the `reflect`
 package were not present in 1.0.
 Most of the buffered channel types in this package are backed by a very fast
 queue implementation that used to be built into this package but has now been
 extracted into its own package at https://github.com/eapache/queue.
 *Note:* Several types in this package provide so-called "infinite" buffers. Be
 very careful using these, as no buffer is truly infinite. If such a buffer
 grows too large your program will run out of memory and crash. Caveat emptor.
--- a/vendor/github.com/eapache/channels/batching_channel.go
+++ b/vendor/github.com/eapache/channels/batching_channel.go
@@ -0,0 +1,87 @@
 package channels
 // BatchingChannel implements the Channel interface, with the change that instead of producing individual elements
 // on Out(), it batches together the entire internal buffer each time. Trying to construct an unbuffered batching channel
 // will panic, that configuration is not supported (and provides no benefit over an unbuffered NativeChannel).
 type BatchingChannel struct {
 	input, output chan interface{}
 	length        chan int
 	buffer        []interface{}
 	size          BufferCap
 }
 func NewBatchingChannel(size BufferCap) *BatchingChannel {
 	if size == None {
 		panic("channels: BatchingChannel does not support unbuffered behaviour")
 	}
 	if size < 0 && size != Infinity {
 		panic("channels: invalid negative size in NewBatchingChannel")
 	}
 	ch := &BatchingChannel{
 		input:  make(chan interface{}),
 		output: make(chan interface{}),
 		length: make(chan int),
 		size:   size,
 	}
 	go ch.batchingBuffer()
 	return ch
 }
 func (ch *BatchingChannel) In() chan<- interface{} {
 	return ch.input
 }
 // Out returns a <-chan interface{} in order that BatchingChannel conforms to the standard Channel interface provided
 // by this package, however each output value is guaranteed to be of type []interface{} - a slice collecting the most
 // recent batch of values sent on the In channel. The slice is guaranteed to not be empty or nil. In practice the net
 // result is that you need an additional type assertion to access the underlying values.
 func (ch *BatchingChannel) Out() <-chan interface{} {
 	return ch.output
 }
 func (ch *BatchingChannel) Len() int {
 	return <-ch.length
 }
 func (ch *BatchingChannel) Cap() BufferCap {
 	return ch.size
 }
 func (ch *BatchingChannel) Close() {
 	close(ch.input)
 }
 func (ch *BatchingChannel) batchingBuffer() {
 	var input, output, nextInput chan interface{}
 	nextInput = ch.input
 	input = nextInput
 	for input != nil || output != nil {
 		select {
 		case elem, open := <-input:
 			if open {
 				ch.buffer = append(ch.buffer, elem)
 			} else {
 				input = nil
 				nextInput = nil
 			}
 		case output <- ch.buffer:
 			ch.buffer = nil
 		case ch.length <- len(ch.buffer):
 		}
 		if len(ch.buffer) == 0 {
 			input = nextInput
 			output = nil
 		} else if ch.size != Infinity && len(ch.buffer) >= int(ch.size) {
 			input = nil
 			output = ch.output
 		} else {
 			input = nextInput
 			output = ch.output
 		}
 	}
 	close(ch.output)
 	close(ch.length)
 }
--- a/vendor/github.com/eapache/channels/black_hole.go
+++ b/vendor/github.com/eapache/channels/black_hole.go
@@ -0,0 +1,54 @@
 package channels
 // BlackHole implements the InChannel interface and provides an analogue for the "Discard" variable in
 // the ioutil package - it never blocks, and simply discards every value it reads. The number of items
 // discarded in this way is counted and returned from Len.
 type BlackHole struct {
 	input  chan interface{}
 	length chan int
 	count  int
 }
 func NewBlackHole() *BlackHole {
 	ch := &BlackHole{
 		input:  make(chan interface{}),
 		length: make(chan int),
 	}
 	go ch.discard()
 	return ch
 }
 func (ch *BlackHole) In() chan<- interface{} {
 	return ch.input
 }
 func (ch *BlackHole) Len() int {
 	val, open := <-ch.length
 	if open {
 		return val
 	} else {
 		return ch.count
 	}
 }
 func (ch *BlackHole) Cap() BufferCap {
 	return Infinity
 }
 func (ch *BlackHole) Close() {
 	close(ch.input)
 }
 func (ch *BlackHole) discard() {
 	for {
 		select {
 		case _, open := <-ch.input:
 			if !open {
 				close(ch.length)
 				return
 			}
 			ch.count++
 		case ch.length <- ch.count:
 		}
 	}
 }
--- a/vendor/github.com/eapache/channels/channels.go
+++ b/vendor/github.com/eapache/channels/channels.go
@@ -0,0 +1,277 @@
 /*
 Package channels provides a collection of helper functions, interfaces and implementations for
 working with and extending the capabilities of golang's existing channels. The main interface of
 interest is Channel, though sub-interfaces are also provided for cases where the full Channel interface
 cannot be met (for example, InChannel for write-only channels).
 For integration with native typed golang channels, functions Wrap and Unwrap are provided which do the
 appropriate type conversions. The NativeChannel, NativeInChannel and NativeOutChannel type definitions
 are also provided for use with native channels which already carry values of type interface{}.
 The heart of the package consists of several distinct implementations of the Channel interface, including
 channels backed by special buffers (resizable, infinite, ring buffers, etc) and other useful types. A
 "black hole" channel for discarding unwanted values (similar in purpose to ioutil.Discard or /dev/null)
 rounds out the set.
 Helper functions for operating on Channels include Pipe and Tee (which behave much like their Unix
 namesakes), as well as Multiplex and Distribute. "Weak" versions of these functions also exist, which
 do not close their output channel(s) on completion.
 Due to limitations of Go's type system, importing this library directly is often not practical for
 production code. It serves equally well, however, as a reference guide and template for implementing
 many common idioms; if you use it in this way I would appreciate the inclusion of some sort of credit
 in the resulting code.
 Warning: several types in this package provide so-called "infinite" buffers. Be *very* careful using
 these, as no buffer is truly infinite - if such a buffer grows too large your program will run out of
 memory and crash. Caveat emptor.
 */
 package channels
 import "reflect"
 // BufferCap represents the capacity of the buffer backing a channel. Valid values consist of all
 // positive integers, as well as the special values below.
 type BufferCap int
 const (
 	// None is the capacity for channels that have no buffer at all.
 	None BufferCap = 0
 	// Infinity is the capacity for channels with no limit on their buffer size.
 	Infinity BufferCap = -1
 )
 // Buffer is an interface for any channel that provides access to query the state of its buffer.
 // Even unbuffered channels can implement this interface by simply returning 0 from Len() and None from Cap().
 type Buffer interface {
 	Len() int       // The number of elements currently buffered.
 	Cap() BufferCap // The maximum number of elements that can be buffered.
 }
 // SimpleInChannel is an interface representing a writeable channel that does not necessarily
 // implement the Buffer interface.
 type SimpleInChannel interface {
 	In() chan<- interface{} // The writeable end of the channel.
 	Close()                 // Closes the channel. It is an error to write to In() after calling Close().
 }
 // InChannel is an interface representing a writeable channel with a buffer.
 type InChannel interface {
 	SimpleInChannel
 	Buffer
 }
 // SimpleOutChannel is an interface representing a readable channel that does not necessarily
 // implement the Buffer interface.
 type SimpleOutChannel interface {
 	Out() <-chan interface{} // The readable end of the channel.
 }
 // OutChannel is an interface representing a readable channel implementing the Buffer interface.
 type OutChannel interface {
 	SimpleOutChannel
 	Buffer
 }
 // SimpleChannel is an interface representing a channel that is both readable and writeable,
 // but does not necessarily implement the Buffer interface.
 type SimpleChannel interface {
 	SimpleInChannel
 	SimpleOutChannel
 }
 // Channel is an interface representing a channel that is readable, writeable and implements
 // the Buffer interface
 type Channel interface {
 	SimpleChannel
 	Buffer
 }
 func pipe(input SimpleOutChannel, output SimpleInChannel, closeWhenDone bool) {
 	for elem := range input.Out() {
 		output.In() <- elem
 	}
 	if closeWhenDone {
 		output.Close()
 	}
 }
 func multiplex(output SimpleInChannel, inputs []SimpleOutChannel, closeWhenDone bool) {
 	inputCount := len(inputs)
 	cases := make([]reflect.SelectCase, inputCount)
 	for i := range cases {
 		cases[i].Dir = reflect.SelectRecv
 		cases[i].Chan = reflect.ValueOf(inputs[i].Out())
 	}
 	for inputCount > 0 {
 		chosen, recv, recvOK := reflect.Select(cases)
 		if recvOK {
 			output.In() <- recv.Interface()
 		} else {
 			cases[chosen].Chan = reflect.ValueOf(nil)
 			inputCount--
 		}
 	}
 	if closeWhenDone {
 		output.Close()
 	}
 }
 func tee(input SimpleOutChannel, outputs []SimpleInChannel, closeWhenDone bool) {
 	cases := make([]reflect.SelectCase, len(outputs))
 	for i := range cases {
 		cases[i].Dir = reflect.SelectSend
 	}
 	for elem := range input.Out() {
 		for i := range cases {
 			cases[i].Chan = reflect.ValueOf(outputs[i].In())
 			cases[i].Send = reflect.ValueOf(elem)
 		}
 		for _ = range cases {
 			chosen, _, _ := reflect.Select(cases)
 			cases[chosen].Chan = reflect.ValueOf(nil)
 		}
 	}
 	if closeWhenDone {
 		for i := range outputs {
 			outputs[i].Close()
 		}
 	}
 }
 func distribute(input SimpleOutChannel, outputs []SimpleInChannel, closeWhenDone bool) {
 	cases := make([]reflect.SelectCase, len(outputs))
 	for i := range cases {
 		cases[i].Dir = reflect.SelectSend
 		cases[i].Chan = reflect.ValueOf(outputs[i].In())
 	}
 	for elem := range input.Out() {
 		for i := range cases {
 			cases[i].Send = reflect.ValueOf(elem)
 		}
 		reflect.Select(cases)
 	}
 	if closeWhenDone {
 		for i := range outputs {
 			outputs[i].Close()
 		}
 	}
 }
 // Pipe connects the input channel to the output channel so that
 // they behave as if a single channel.
 func Pipe(input SimpleOutChannel, output SimpleInChannel) {
 	go pipe(input, output, true)
 }
 // Multiplex takes an arbitrary number of input channels and multiplexes their output into a single output
 // channel. When all input channels have been closed, the output channel is closed. Multiplex with a single
 // input channel is equivalent to Pipe (though slightly less efficient).
 func Multiplex(output SimpleInChannel, inputs ...SimpleOutChannel) {
 	if len(inputs) == 0 {
 		panic("channels: Multiplex requires at least one input")
 	}
 	go multiplex(output, inputs, true)
 }
 // Tee (like its Unix namesake) takes a single input channel and an arbitrary number of output channels
 // and duplicates each input into every output. When the input channel is closed, all outputs channels are closed.
 // Tee with a single output channel is equivalent to Pipe (though slightly less efficient).
 func Tee(input SimpleOutChannel, outputs ...SimpleInChannel) {
 	if len(outputs) == 0 {
 		panic("channels: Tee requires at least one output")
 	}
 	go tee(input, outputs, true)
 }
 // Distribute takes a single input channel and an arbitrary number of output channels and duplicates each input
 // into *one* available output. If multiple outputs are waiting for a value, one is chosen at random. When the
 // input channel is closed, all outputs channels are closed. Distribute with a single output channel is
 // equivalent to Pipe (though slightly less efficient).
 func Distribute(input SimpleOutChannel, outputs ...SimpleInChannel) {
 	if len(outputs) == 0 {
 		panic("channels: Distribute requires at least one output")
 	}
 	go distribute(input, outputs, true)
 }
 // WeakPipe behaves like Pipe (connecting the two channels) except that it does not close
 // the output channel when the input channel is closed.
 func WeakPipe(input SimpleOutChannel, output SimpleInChannel) {
 	go pipe(input, output, false)
 }
 // WeakMultiplex behaves like Multiplex (multiplexing multiple inputs into a single output) except that it does not close
 // the output channel when the input channels are closed.
 func WeakMultiplex(output SimpleInChannel, inputs ...SimpleOutChannel) {
 	if len(inputs) == 0 {
 		panic("channels: WeakMultiplex requires at least one input")
 	}
 	go multiplex(output, inputs, false)
 }
 // WeakTee behaves like Tee (duplicating a single input into multiple outputs) except that it does not close
 // the output channels when the input channel is closed.
 func WeakTee(input SimpleOutChannel, outputs ...SimpleInChannel) {
 	if len(outputs) == 0 {
 		panic("channels: WeakTee requires at least one output")
 	}
 	go tee(input, outputs, false)
 }
 // WeakDistribute behaves like Distribute (distributing a single input amongst multiple outputs) except that
 // it does not close the output channels when the input channel is closed.
 func WeakDistribute(input SimpleOutChannel, outputs ...SimpleInChannel) {
 	if len(outputs) == 0 {
 		panic("channels: WeakDistribute requires at least one output")
 	}
 	go distribute(input, outputs, false)
 }
 // Wrap takes any readable channel type (chan or <-chan but not chan<-) and
 // exposes it as a SimpleOutChannel for easy integration with existing channel sources.
 // It panics if the input is not a readable channel.
 func Wrap(ch interface{}) SimpleOutChannel {
 	t := reflect.TypeOf(ch)
 	if t.Kind() != reflect.Chan || t.ChanDir()&reflect.RecvDir == 0 {
 		panic("channels: input to Wrap must be readable channel")
 	}
 	realChan := make(chan interface{})
 	go func() {
 		v := reflect.ValueOf(ch)
 		for {
 			x, ok := v.Recv()
 			if !ok {
 				close(realChan)
 				return
 			}
 			realChan <- x.Interface()
 		}
 	}()
 	return NativeOutChannel(realChan)
 }
 // Unwrap takes a SimpleOutChannel and uses reflection to pipe it to a typed native channel for
 // easy integration with existing channel sources. Output can be any writable channel type (chan or chan<-).
 // It panics if the output is not a writable channel, or if a value is received that cannot be sent on the
 // output channel.
 func Unwrap(input SimpleOutChannel, output interface{}) {
 	t := reflect.TypeOf(output)
 	if t.Kind() != reflect.Chan || t.ChanDir()&reflect.SendDir == 0 {
 		panic("channels: input to Unwrap must be readable channel")
 	}
 	go func() {
 		v := reflect.ValueOf(output)
 		for {
 			x, ok := <-input.Out()
 			if !ok {
 				v.Close()
 				return
 			}
 			v.Send(reflect.ValueOf(x))
 		}
 	}()
 }
--- a/vendor/github.com/eapache/channels/infinite_channel.go
+++ b/vendor/github.com/eapache/channels/infinite_channel.go
@@ -0,0 +1,72 @@
 package channels
 import "github.com/eapache/queue"
 // InfiniteChannel implements the Channel interface with an infinite buffer between the input and the output.
 type InfiniteChannel struct {
 	input, output chan interface{}
 	length        chan int
 	buffer        *queue.Queue
 }
 func NewInfiniteChannel() *InfiniteChannel {
 	ch := &InfiniteChannel{
 		input:  make(chan interface{}),
 		output: make(chan interface{}),
 		length: make(chan int),
 		buffer: queue.New(),
 	}
 	go ch.infiniteBuffer()
 	return ch
 }
 func (ch *InfiniteChannel) In() chan<- interface{} {
 	return ch.input
 }
 func (ch *InfiniteChannel) Out() <-chan interface{} {
 	return ch.output
 }
 func (ch *InfiniteChannel) Len() int {
 	return <-ch.length
 }
 func (ch *InfiniteChannel) Cap() BufferCap {
 	return Infinity
 }
 func (ch *InfiniteChannel) Close() {
 	close(ch.input)
 }
 func (ch *InfiniteChannel) infiniteBuffer() {
 	var input, output chan interface{}
 	var next interface{}
 	input = ch.input
 	for input != nil || output != nil {
 		select {
 		case elem, open := <-input:
 			if open {
 				ch.buffer.Add(elem)
 			} else {
 				input = nil
 			}
 		case output <- next:
 			ch.buffer.Remove()
 		case ch.length <- ch.buffer.Length():
 		}
 		if ch.buffer.Length() > 0 {
 			output = ch.output
 			next = ch.buffer.Peek()
 		} else {
 			output = nil
 			next = nil
 		}
 	}
 	close(ch.output)
 	close(ch.length)
 }
--- a/vendor/github.com/eapache/channels/native_channel.go
+++ b/vendor/github.com/eapache/channels/native_channel.go
@@ -0,0 +1,92 @@
 package channels
 // NativeInChannel implements the InChannel interface by wrapping a native go write-only channel.
 type NativeInChannel chan<- interface{}
 func (ch NativeInChannel) In() chan<- interface{} {
 	return ch
 }
 func (ch NativeInChannel) Len() int {
 	return len(ch)
 }
 func (ch NativeInChannel) Cap() BufferCap {
 	return BufferCap(cap(ch))
 }
 func (ch NativeInChannel) Close() {
 	close(ch)
 }
 // NativeOutChannel implements the OutChannel interface by wrapping a native go read-only channel.
 type NativeOutChannel <-chan interface{}
 func (ch NativeOutChannel) Out() <-chan interface{} {
 	return ch
 }
 func (ch NativeOutChannel) Len() int {
 	return len(ch)
 }
 func (ch NativeOutChannel) Cap() BufferCap {
 	return BufferCap(cap(ch))
 }
 // NativeChannel implements the Channel interface by wrapping a native go channel.
 type NativeChannel chan interface{}
 // NewNativeChannel makes a new NativeChannel with the given buffer size. Just a convenience wrapper
 // to avoid having to cast the result of make().
 func NewNativeChannel(size BufferCap) NativeChannel {
 	return make(chan interface{}, size)
 }
 func (ch NativeChannel) In() chan<- interface{} {
 	return ch
 }
 func (ch NativeChannel) Out() <-chan interface{} {
 	return ch
 }
 func (ch NativeChannel) Len() int {
 	return len(ch)
 }
 func (ch NativeChannel) Cap() BufferCap {
 	return BufferCap(cap(ch))
 }
 func (ch NativeChannel) Close() {
 	close(ch)
 }
 // DeadChannel is a placeholder implementation of the Channel interface with no buffer
 // that is never ready for reading or writing. Closing a dead channel is a no-op.
 // Behaves almost like NativeChannel(nil) except that closing a nil NativeChannel will panic.
 type DeadChannel struct{}
 func NewDeadChannel() DeadChannel {
 	return DeadChannel{}
 }
 func (ch DeadChannel) In() chan<- interface{} {
 	return nil
 }
 func (ch DeadChannel) Out() <-chan interface{} {
 	return nil
 }
 func (ch DeadChannel) Len() int {
 	return 0
 }
 func (ch DeadChannel) Cap() BufferCap {
 	return BufferCap(0)
 }
 func (ch DeadChannel) Close() {
 }
--- a/vendor/github.com/eapache/channels/overflowing_channel.go
+++ b/vendor/github.com/eapache/channels/overflowing_channel.go
@@ -0,0 +1,113 @@
 package channels
 import "github.com/eapache/queue"
 // OverflowingChannel implements the Channel interface in a way that never blocks the writer.
 // Specifically, if a value is written to an OverflowingChannel when its buffer is full
 // (or, in an unbuffered case, when the recipient is not ready) then that value is simply discarded.
 // Note that Go's scheduler can cause discarded values when they could be avoided, simply by scheduling
 // the writer before the reader, so caveat emptor.
 // For the opposite behaviour (discarding the oldest element, not the newest) see RingChannel.
 type OverflowingChannel struct {
 	input, output chan interface{}
 	length        chan int
 	buffer        *queue.Queue
 	size          BufferCap
 }
 func NewOverflowingChannel(size BufferCap) *OverflowingChannel {
 	if size < 0 && size != Infinity {
 		panic("channels: invalid negative size in NewOverflowingChannel")
 	}
 	ch := &OverflowingChannel{
 		input:  make(chan interface{}),
 		output: make(chan interface{}),
 		length: make(chan int),
 		size:   size,
 	}
 	if size == None {
 		go ch.overflowingDirect()
 	} else {
 		ch.buffer = queue.New()
 		go ch.overflowingBuffer()
 	}
 	return ch
 }
 func (ch *OverflowingChannel) In() chan<- interface{} {
 	return ch.input
 }
 func (ch *OverflowingChannel) Out() <-chan interface{} {
 	return ch.output
 }
 func (ch *OverflowingChannel) Len() int {
 	if ch.size == None {
 		return 0
 	} else {
 		return <-ch.length
 	}
 }
 func (ch *OverflowingChannel) Cap() BufferCap {
 	return ch.size
 }
 func (ch *OverflowingChannel) Close() {
 	close(ch.input)
 }
 // for entirely unbuffered cases
 func (ch *OverflowingChannel) overflowingDirect() {
 	for elem := range ch.input {
 		// if we can't write it immediately, drop it and move on
 		select {
 		case ch.output <- elem:
 		default:
 		}
 	}
 	close(ch.output)
 }
 // for all buffered cases
 func (ch *OverflowingChannel) overflowingBuffer() {
 	var input, output chan interface{}
 	var next interface{}
 	input = ch.input
 	for input != nil || output != nil {
 		select {
 		// Prefer to write if possible, which is surprisingly effective in reducing
 		// dropped elements due to overflow. The naive read/write select chooses randomly
 		// when both channels are ready, which produces unnecessary drops 50% of the time.
 		case output <- next:
 			ch.buffer.Remove()
 		default:
 			select {
 			case elem, open := <-input:
 				if open {
 					if ch.size == Infinity || ch.buffer.Length() < int(ch.size) {
 						ch.buffer.Add(elem)
 					}
 				} else {
 					input = nil
 				}
 			case output <- next:
 				ch.buffer.Remove()
 			case ch.length <- ch.buffer.Length():
 			}
 		}
 		if ch.buffer.Length() > 0 {
 			output = ch.output
 			next = ch.buffer.Peek()
 		} else {
 			output = nil
 			next = nil
 		}
 	}
 	close(ch.output)
 	close(ch.length)
 }
--- a/vendor/github.com/eapache/channels/resizable_channel.go
+++ b/vendor/github.com/eapache/channels/resizable_channel.go
@@ -0,0 +1,109 @@
 package channels
 import "github.com/eapache/queue"
 // ResizableChannel implements the Channel interface with a resizable buffer between the input and the output.
 // The channel initially has a buffer size of 1, but can be resized by calling Resize().
 //
 // Resizing to a buffer capacity of None is, unfortunately, not supported and will panic
 // (see https://github.com/eapache/channels/issues/1).
 // Resizing back and forth between a finite and infinite buffer is fully supported.
 type ResizableChannel struct {
 	input, output    chan interface{}
 	length           chan int
 	capacity, resize chan BufferCap
 	size             BufferCap
 	buffer           *queue.Queue
 }
 func NewResizableChannel() *ResizableChannel {
 	ch := &ResizableChannel{
 		input:    make(chan interface{}),
 		output:   make(chan interface{}),
 		length:   make(chan int),
 		capacity: make(chan BufferCap),
 		resize:   make(chan BufferCap),
 		size:     1,
 		buffer:   queue.New(),
 	}
 	go ch.magicBuffer()
 	return ch
 }
 func (ch *ResizableChannel) In() chan<- interface{} {
 	return ch.input
 }
 func (ch *ResizableChannel) Out() <-chan interface{} {
 	return ch.output
 }
 func (ch *ResizableChannel) Len() int {
 	return <-ch.length
 }
 func (ch *ResizableChannel) Cap() BufferCap {
 	val, open := <-ch.capacity
 	if open {
 		return val
 	} else {
 		return ch.size
 	}
 }
 func (ch *ResizableChannel) Close() {
 	close(ch.input)
 }
 func (ch *ResizableChannel) Resize(newSize BufferCap) {
 	if newSize == None {
 		panic("channels: ResizableChannel does not support unbuffered behaviour")
 	}
 	if newSize < 0 && newSize != Infinity {
 		panic("channels: invalid negative size trying to resize channel")
 	}
 	ch.resize <- newSize
 }
 func (ch *ResizableChannel) magicBuffer() {
 	var input, output, nextInput chan interface{}
 	var next interface{}
 	nextInput = ch.input
 	input = nextInput
 	for input != nil || output != nil {
 		select {
 		case elem, open := <-input:
 			if open {
 				ch.buffer.Add(elem)
 			} else {
 				input = nil
 				nextInput = nil
 			}
 		case output <- next:
 			ch.buffer.Remove()
 		case ch.size = <-ch.resize:
 		case ch.length <- ch.buffer.Length():
 		case ch.capacity <- ch.size:
 		}
 		if ch.buffer.Length() == 0 {
 			output = nil
 			next = nil
 		} else {
 			output = ch.output
 			next = ch.buffer.Peek()
 		}
 		if ch.size != Infinity && ch.buffer.Length() >= int(ch.size) {
 			input = nil
 		} else {
 			input = nextInput
 		}
 	}
 	close(ch.output)
 	close(ch.resize)
 	close(ch.length)
 	close(ch.capacity)
 }
--- a/vendor/github.com/eapache/channels/ring_channel.go
+++ b/vendor/github.com/eapache/channels/ring_channel.go
@@ -0,0 +1,114 @@
 package channels
 import "github.com/eapache/queue"
 // RingChannel implements the Channel interface in a way that never blocks the writer.
 // Specifically, if a value is written to a RingChannel when its buffer is full then the oldest
 // value in the buffer is discarded to make room (just like a standard ring-buffer).
 // Note that Go's scheduler can cause discarded values when they could be avoided, simply by scheduling
 // the writer before the reader, so caveat emptor.
 // For the opposite behaviour (discarding the newest element, not the oldest) see OverflowingChannel.
 type RingChannel struct {
 	input, output chan interface{}
 	length        chan int
 	buffer        *queue.Queue
 	size          BufferCap
 }
 func NewRingChannel(size BufferCap) *RingChannel {
 	if size < 0 && size != Infinity {
 		panic("channels: invalid negative size in NewRingChannel")
 	}
 	ch := &RingChannel{
 		input:  make(chan interface{}),
 		output: make(chan interface{}),
 		buffer: queue.New(),
 		size:   size,
 	}
 	if size == None {
 		go ch.overflowingDirect()
 	} else {
 		ch.length = make(chan int)
 		go ch.ringBuffer()
 	}
 	return ch
 }
 func (ch *RingChannel) In() chan<- interface{} {
 	return ch.input
 }
 func (ch *RingChannel) Out() <-chan interface{} {
 	return ch.output
 }
 func (ch *RingChannel) Len() int {
 	if ch.size == None {
 		return 0
 	} else {
 		return <-ch.length
 	}
 }
 func (ch *RingChannel) Cap() BufferCap {
 	return ch.size
 }
 func (ch *RingChannel) Close() {
 	close(ch.input)
 }
 // for entirely unbuffered cases
 func (ch *RingChannel) overflowingDirect() {
 	for elem := range ch.input {
 		// if we can't write it immediately, drop it and move on
 		select {
 		case ch.output <- elem:
 		default:
 		}
 	}
 	close(ch.output)
 }
 // for all buffered cases
 func (ch *RingChannel) ringBuffer() {
 	var input, output chan interface{}
 	var next interface{}
 	input = ch.input
 	for input != nil || output != nil {
 		select {
 		// Prefer to write if possible, which is surprisingly effective in reducing
 		// dropped elements due to overflow. The naive read/write select chooses randomly
 		// when both channels are ready, which produces unnecessary drops 50% of the time.
 		case output <- next:
 			ch.buffer.Remove()
 		default:
 			select {
 			case elem, open := <-input:
 				if open {
 					ch.buffer.Add(elem)
 					if ch.size != Infinity && ch.buffer.Length() > int(ch.size) {
 						ch.buffer.Remove()
 					}
 				} else {
 					input = nil
 				}
 			case output <- next:
 				ch.buffer.Remove()
 			case ch.length <- ch.buffer.Length():
 			}
 		}
 		if ch.buffer.Length() > 0 {
 			output = ch.output
 			next = ch.buffer.Peek()
 		} else {
 			output = nil
 			next = nil
 		}
 	}
 	close(ch.output)
 	close(ch.length)
 }
--- a/vendor/github.com/eapache/channels/shared_buffer.go
+++ b/vendor/github.com/eapache/channels/shared_buffer.go
@@ -0,0 +1,167 @@
 package channels
 import (
 	"reflect"
 	"github.com/eapache/queue"
 )
 //sharedBufferChannel implements SimpleChannel and is created by the public
 //SharedBuffer type below
 type sharedBufferChannel struct {
 	in     chan interface{}
 	out    chan interface{}
 	buf    *queue.Queue
 	closed bool
 }
 func (sch *sharedBufferChannel) In() chan<- interface{} {
 	return sch.in
 }
 func (sch *sharedBufferChannel) Out() <-chan interface{} {
 	return sch.out
 }
 func (sch *sharedBufferChannel) Close() {
 	close(sch.in)
 }
 //SharedBuffer implements the Buffer interface, and permits multiple SimpleChannel instances to "share" a single buffer.
 //Each channel spawned by NewChannel has its own internal queue (so values flowing through do not get mixed up with
 //other channels) but the total number of elements buffered by all spawned channels is limited to a single capacity. This
 //means *all* such channels block and unblock for writing together. The primary use case is for implementing pipeline-style
 //parallelism with goroutines, limiting the total number of elements in the pipeline without limiting the number of elements
 //at any particular step.
 type SharedBuffer struct {
 	cases []reflect.SelectCase   // 2n+1 of these; [0] is for control, [1,3,5...] for recv, [2,4,6...] for send
 	chans []*sharedBufferChannel // n of these
 	count int
 	size  BufferCap
 	in    chan *sharedBufferChannel
 }
 func NewSharedBuffer(size BufferCap) *SharedBuffer {
 	if size < 0 && size != Infinity {
 		panic("channels: invalid negative size in NewSharedBuffer")
 	} else if size == None {
 		panic("channels: SharedBuffer does not support unbuffered behaviour")
 	}
 	buf := &SharedBuffer{
 		size: size,
 		in:   make(chan *sharedBufferChannel),
 	}
 	buf.cases = append(buf.cases, reflect.SelectCase{
 		Dir:  reflect.SelectRecv,
 		Chan: reflect.ValueOf(buf.in),
 	})
 	go buf.mainLoop()
 	return buf
 }
 //NewChannel spawns and returns a new channel sharing the underlying buffer.
 func (buf *SharedBuffer) NewChannel() SimpleChannel {
 	ch := &sharedBufferChannel{
 		in:  make(chan interface{}),
 		out: make(chan interface{}),
 		buf: queue.New(),
 	}
 	buf.in <- ch
 	return ch
 }
 //Close shuts down the SharedBuffer. It is an error to call Close while channels are still using
 //the buffer (I'm not really sure what would happen if you do so).
 func (buf *SharedBuffer) Close() {
 	// TODO: what if there are still active channels using this buffer?
 	close(buf.in)
 }
 func (buf *SharedBuffer) mainLoop() {
 	for {
 		i, val, ok := reflect.Select(buf.cases)
 		if i == 0 {
 			if !ok {
 				//Close was called on the SharedBuffer itself
 				return
 			}
 			//NewChannel was called on the SharedBuffer
 			ch := val.Interface().(*sharedBufferChannel)
 			buf.chans = append(buf.chans, ch)
 			buf.cases = append(buf.cases,
 				reflect.SelectCase{Dir: reflect.SelectRecv},
 				reflect.SelectCase{Dir: reflect.SelectSend},
 			)
 			if buf.size == Infinity || buf.count < int(buf.size) {
 				buf.cases[len(buf.cases)-2].Chan = reflect.ValueOf(ch.in)
 			}
 		} else if i%2 == 0 {
 			//Send
 			if buf.count == int(buf.size) {
 				//room in the buffer again, re-enable all recv cases
 				for j := range buf.chans {
 					if !buf.chans[j].closed {
 						buf.cases[(j*2)+1].Chan = reflect.ValueOf(buf.chans[j].in)
 					}
 				}
 			}
 			buf.count--
 			ch := buf.chans[(i-1)/2]
 			if ch.buf.Length() > 0 {
 				buf.cases[i].Send = reflect.ValueOf(ch.buf.Peek())
 				ch.buf.Remove()
 			} else {
 				//nothing left for this channel to send, disable sending
 				buf.cases[i].Chan = reflect.Value{}
 				buf.cases[i].Send = reflect.Value{}
 				if ch.closed {
 					// and it was closed, so close the output channel
 					//TODO: shrink slice
 					close(ch.out)
 				}
 			}
 		} else {
 			ch := buf.chans[i/2]
 			if ok {
 				//Receive
 				buf.count++
 				if ch.buf.Length() == 0 && !buf.cases[i+1].Chan.IsValid() {
 					//this channel now has something to send
 					buf.cases[i+1].Chan = reflect.ValueOf(ch.out)
 					buf.cases[i+1].Send = val
 				} else {
 					ch.buf.Add(val.Interface())
 				}
 				if buf.count == int(buf.size) {
 					//buffer full, disable recv cases
 					for j := range buf.chans {
 						buf.cases[(j*2)+1].Chan = reflect.Value{}
 					}
 				}
 			} else {
 				//Close
 				buf.cases[i].Chan = reflect.Value{}
 				ch.closed = true
 				if ch.buf.Length() == 0 && !buf.cases[i+1].Chan.IsValid() {
 					//nothing pending, close the out channel right away
 					//TODO: shrink slice
 					close(ch.out)
 				}
 			}
 		}
 	}
 }
 func (buf *SharedBuffer) Len() int {
 	return buf.count
 }
 func (buf *SharedBuffer) Cap() BufferCap {
 	return buf.size
 }
--- a/vendor/github.com/eapache/queue/.gitignore
+++ b/vendor/github.com/eapache/queue/.gitignore
@@ -0,0 +1,23 @@
 # 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
 *.test
--- a/vendor/github.com/eapache/queue/.travis.yml
+++ b/vendor/github.com/eapache/queue/.travis.yml
@@ -0,0 +1,7 @@
 language: go
 sudo: false
 go:
  - 1.2
  - 1.3
  - 1.4
--- a/vendor/github.com/eapache/queue/LICENSE
+++ b/vendor/github.com/eapache/queue/LICENSE
@@ -0,0 +1,21 @@
 The MIT License (MIT)
 Copyright (c) 2014 Evan Huus
 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/eapache/queue/README.md
+++ b/vendor/github.com/eapache/queue/README.md
@@ -0,0 +1,16 @@
 Queue
 =====
 [![Build Status](https://travis-ci.org/eapache/queue.svg)](https://travis-ci.org/eapache/queue)
 [![GoDoc](https://godoc.org/github.com/eapache/queue?status.png)](https://godoc.org/github.com/eapache/queue)
 [![Code of Conduct](https://img.shields.io/badge/code%20of%20conduct-active-blue.svg)](https://eapache.github.io/conduct.html)
 A fast Golang queue using a ring-buffer, based on the version suggested by Dariusz Górecki.
 Using this instead of other, simpler, queue implementations (slice+append or linked list) provides
 substantial memory and time benefits, and fewer GC pauses.
 The queue implemented here is as fast as it is in part because it is *not* thread-safe.
 Follows semantic versioning using https://gopkg.in/ - import from
 [`gopkg.in/eapache/queue.v1`](https://gopkg.in/eapache/queue.v1)
 for guaranteed API stability.
--- a/vendor/github.com/eapache/queue/queue.go
+++ b/vendor/github.com/eapache/queue/queue.go
@@ -0,0 +1,102 @@
 /*
 Package queue provides a fast, ring-buffer queue based on the version suggested by Dariusz Górecki.
 Using this instead of other, simpler, queue implementations (slice+append or linked list) provides
 substantial memory and time benefits, and fewer GC pauses.
 The queue implemented here is as fast as it is for an additional reason: it is *not* thread-safe.
 */
 package queue
 // minQueueLen is smallest capacity that queue may have.
 // Must be power of 2 for bitwise modulus: x % n == x & (n - 1).
 const minQueueLen = 16
 // Queue represents a single instance of the queue data structure.
 type Queue struct {
 	buf               []interface{}
 	head, tail, count int
 }
 // New constructs and returns a new Queue.
 func New() *Queue {
 	return &Queue{
 		buf: make([]interface{}, minQueueLen),
 	}
 }
 // Length returns the number of elements currently stored in the queue.
 func (q *Queue) Length() int {
 	return q.count
 }
 // resizes the queue to fit exactly twice its current contents
 // this can result in shrinking if the queue is less than half-full
 func (q *Queue) resize() {
 	newBuf := make([]interface{}, q.count<<1)
 	if q.tail > q.head {
 		copy(newBuf, q.buf[q.head:q.tail])
 	} else {
 		n := copy(newBuf, q.buf[q.head:])
 		copy(newBuf[n:], q.buf[:q.tail])
 	}
 	q.head = 0
 	q.tail = q.count
 	q.buf = newBuf
 }
 // Add puts an element on the end of the queue.
 func (q *Queue) Add(elem interface{}) {
 	if q.count == len(q.buf) {
 		q.resize()
 	}
 	q.buf[q.tail] = elem
 	// bitwise modulus
 	q.tail = (q.tail + 1) & (len(q.buf) - 1)
 	q.count++
 }
 // Peek returns the element at the head of the queue. This call panics
 // if the queue is empty.
 func (q *Queue) Peek() interface{} {
 	if q.count <= 0 {
 		panic("queue: Peek() called on empty queue")
 	}
 	return q.buf[q.head]
 }
 // Get returns the element at index i in the queue. If the index is
 // invalid, the call will panic. This method accepts both positive and
 // negative index values. Index 0 refers to the first element, and
 // index -1 refers to the last.
 func (q *Queue) Get(i int) interface{} {
 	// If indexing backwards, convert to positive index.
 	if i < 0 {
 		i += q.count
 	}
 	if i < 0 || i >= q.count {
 		panic("queue: Get() called with index out of range")
 	}
 	// bitwise modulus
 	return q.buf[(q.head+i)&(len(q.buf)-1)]
 }
 // Remove removes and returns the element from the front of the queue. If the
 // queue is empty, the call will panic.
 func (q *Queue) Remove() interface{} {
 	if q.count <= 0 {
 		panic("queue: Remove() called on empty queue")
 	}
 	ret := q.buf[q.head]
 	q.buf[q.head] = nil
 	// bitwise modulus
 	q.head = (q.head + 1) & (len(q.buf) - 1)
 	q.count--
 	// Resize down if buffer 1/4 full.
 	if len(q.buf) > minQueueLen && (q.count<<2) == len(q.buf) {
 		q.resize()
 	}
 	return ret
 }
--- a/vendor/github.com/fsnotify/fsnotify/.editorconfig
+++ b/vendor/github.com/fsnotify/fsnotify/.editorconfig
@@ -0,0 +1,5 @@
 root = true
 [*]
 indent_style = tab
 indent_size = 4
--- a/vendor/github.com/fsnotify/fsnotify/.gitignore
+++ b/vendor/github.com/fsnotify/fsnotify/.gitignore
@@ -0,0 +1,6 @@
 # Setup a Global .gitignore for OS and editor generated files:
 # https://help.github.com/articles/ignoring-files
 # git config --global core.excludesfile ~/.gitignore_global
 .vagrant
 *.sublime-project
--- a/vendor/github.com/fsnotify/fsnotify/.travis.yml
+++ b/vendor/github.com/fsnotify/fsnotify/.travis.yml
@@ -0,0 +1,30 @@
 sudo: false
 language: go
 go:
  - 1.8.x
  - 1.9.x
  - tip
 matrix:
  allow_failures:
    - go: tip
  fast_finish: true
 before_script:
  - go get -u github.com/golang/lint/golint
 script:
  - go test -v --race ./...
 after_script:
  - test -z "$(gofmt -s -l -w . | tee /dev/stderr)"
  - test -z "$(golint ./...     | tee /dev/stderr)"
  - go vet ./...
 os:
  - linux
  - osx
 notifications:
  email: false
--- a/vendor/github.com/fsnotify/fsnotify/AUTHORS
+++ b/vendor/github.com/fsnotify/fsnotify/AUTHORS
@@ -0,0 +1,52 @@
 # Names should be added to this file as
 #	Name or Organization <email address>
 # The email address is not required for organizations.
 # You can update this list using the following command:
 #
 #   $ git shortlog -se | awk '{print $2 " " $3 " " $4}'
 # Please keep the list sorted.
 Aaron L <aaron@bettercoder.net>
 Adrien Bustany <adrien@bustany.org>
 Amit Krishnan <amit.krishnan@oracle.com>
 Anmol Sethi <me@anmol.io>
 Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
 Bruno Bigras <bigras.bruno@gmail.com>
 Caleb Spare <cespare@gmail.com>
 Case Nelson <case@teammating.com>
 Chris Howey <chris@howey.me> <howeyc@gmail.com>
 Christoffer Buchholz <christoffer.buchholz@gmail.com>
 Daniel Wagner-Hall <dawagner@gmail.com>
 Dave Cheney <dave@cheney.net>
 Evan Phoenix <evan@fallingsnow.net>
 Francisco Souza <f@souza.cc>
 Hari haran <hariharan.uno@gmail.com>
 John C Barstow
 Kelvin Fo <vmirage@gmail.com>
 Ken-ichirou MATSUZAWA <chamas@h4.dion.ne.jp>
 Matt Layher <mdlayher@gmail.com>
 Nathan Youngman <git@nathany.com>
 Nickolai Zeldovich <nickolai@csail.mit.edu>
 Patrick <patrick@dropbox.com>
 Paul Hammond <paul@paulhammond.org>
 Pawel Knap <pawelknap88@gmail.com>
 Pieter Droogendijk <pieter@binky.org.uk>
 Pursuit92 <JoshChase@techpursuit.net>
 Riku Voipio <riku.voipio@linaro.org>
 Rob Figueiredo <robfig@gmail.com>
 Rodrigo Chiossi <rodrigochiossi@gmail.com>
 Slawek Ligus <root@ooz.ie>
 Soge Zhang <zhssoge@gmail.com>
 Tiffany Jernigan <tiffany.jernigan@intel.com>
 Tilak Sharma <tilaks@google.com>
 Tom Payne <twpayne@gmail.com>
 Travis Cline <travis.cline@gmail.com>
 Tudor Golubenco <tudor.g@gmail.com>
 Vahe Khachikyan <vahe@live.ca>
 Yukang <moorekang@gmail.com>
 bronze1man <bronze1man@gmail.com>
 debrando <denis.brandolini@gmail.com>
 henrikedwards <henrik.edwards@gmail.com>
 铁哥 <guotie.9@gmail.com>
--- a/vendor/github.com/fsnotify/fsnotify/CHANGELOG.md
+++ b/vendor/github.com/fsnotify/fsnotify/CHANGELOG.md
@@ -0,0 +1,317 @@
 # Changelog
 ## v1.4.7 / 2018-01-09
 * BSD/macOS: Fix possible deadlock on closing the watcher on kqueue (thanks @nhooyr and @glycerine)
 * Tests: Fix missing verb on format string (thanks @rchiossi)
 * Linux: Fix deadlock in Remove (thanks @aarondl)
 * Linux: Watch.Add improvements (avoid race, fix consistency, reduce garbage) (thanks @twpayne)
 * Docs: Moved FAQ into the README (thanks @vahe)
 * Linux: Properly handle inotify's IN_Q_OVERFLOW event (thanks @zeldovich)
 * Docs: replace references to OS X with macOS
 ## v1.4.2 / 2016-10-10
 * Linux: use InotifyInit1 with IN_CLOEXEC to stop leaking a file descriptor to a child process when using fork/exec [#178](https://github.com/fsnotify/fsnotify/pull/178) (thanks @pattyshack)
 ## v1.4.1 / 2016-10-04
 * Fix flaky inotify stress test on Linux [#177](https://github.com/fsnotify/fsnotify/pull/177) (thanks @pattyshack)
 ## v1.4.0 / 2016-10-01
 * add a String() method to Event.Op [#165](https://github.com/fsnotify/fsnotify/pull/165) (thanks @oozie)
 ## v1.3.1 / 2016-06-28
 * Windows: fix for double backslash when watching the root of a drive [#151](https://github.com/fsnotify/fsnotify/issues/151) (thanks @brunoqc)
 ## v1.3.0 / 2016-04-19
 * Support linux/arm64 by [patching](https://go-review.googlesource.com/#/c/21971/) x/sys/unix and switching to to it from syscall (thanks @suihkulokki) [#135](https://github.com/fsnotify/fsnotify/pull/135)
 ## v1.2.10 / 2016-03-02
 * Fix golint errors in windows.go [#121](https://github.com/fsnotify/fsnotify/pull/121) (thanks @tiffanyfj)
 ## v1.2.9 / 2016-01-13
 kqueue: Fix logic for CREATE after REMOVE [#111](https://github.com/fsnotify/fsnotify/pull/111) (thanks @bep)
 ## v1.2.8 / 2015-12-17
 * kqueue: fix race condition in Close [#105](https://github.com/fsnotify/fsnotify/pull/105) (thanks @djui for reporting the issue and @ppknap for writing a failing test)
 * inotify: fix race in test
 * enable race detection for continuous integration (Linux, Mac, Windows)
 ## v1.2.5 / 2015-10-17
 * inotify: use epoll_create1 for arm64 support (requires Linux 2.6.27 or later) [#100](https://github.com/fsnotify/fsnotify/pull/100) (thanks @suihkulokki)
 * inotify: fix path leaks [#73](https://github.com/fsnotify/fsnotify/pull/73) (thanks @chamaken)
 * kqueue: watch for rename events on subdirectories [#83](https://github.com/fsnotify/fsnotify/pull/83) (thanks @guotie)
 * kqueue: avoid infinite loops from symlinks cycles [#101](https://github.com/fsnotify/fsnotify/pull/101) (thanks @illicitonion)
 ## v1.2.1 / 2015-10-14
 * kqueue: don't watch named pipes [#98](https://github.com/fsnotify/fsnotify/pull/98) (thanks @evanphx)
 ## v1.2.0 / 2015-02-08
 * inotify: use epoll to wake up readEvents [#66](https://github.com/fsnotify/fsnotify/pull/66) (thanks @PieterD)
 * inotify: closing watcher should now always shut down goroutine [#63](https://github.com/fsnotify/fsnotify/pull/63) (thanks @PieterD)
 * kqueue: close kqueue after removing watches, fixes [#59](https://github.com/fsnotify/fsnotify/issues/59)
 ## v1.1.1 / 2015-02-05
 * inotify: Retry read on EINTR [#61](https://github.com/fsnotify/fsnotify/issues/61) (thanks @PieterD)
 ## v1.1.0 / 2014-12-12
 * kqueue: rework internals [#43](https://github.com/fsnotify/fsnotify/pull/43)
    * add low-level functions
    * only need to store flags on directories
    * less mutexes [#13](https://github.com/fsnotify/fsnotify/issues/13)
    * done can be an unbuffered channel
    * remove calls to os.NewSyscallError
 * More efficient string concatenation for Event.String() [#52](https://github.com/fsnotify/fsnotify/pull/52) (thanks @mdlayher)
 * kqueue: fix regression in  rework causing subdirectories to be watched [#48](https://github.com/fsnotify/fsnotify/issues/48)
 * kqueue: cleanup internal watch before sending remove event [#51](https://github.com/fsnotify/fsnotify/issues/51)
 ## v1.0.4 / 2014-09-07
 * kqueue: add dragonfly to the build tags.
 * Rename source code files, rearrange code so exported APIs are at the top.
 * Add done channel to example code. [#37](https://github.com/fsnotify/fsnotify/pull/37) (thanks @chenyukang)
 ## v1.0.3 / 2014-08-19
 * [Fix] Windows MOVED_TO now translates to Create like on BSD and Linux. [#36](https://github.com/fsnotify/fsnotify/issues/36)
 ## v1.0.2 / 2014-08-17
 * [Fix] Missing create events on macOS. [#14](https://github.com/fsnotify/fsnotify/issues/14) (thanks @zhsso)
 * [Fix] Make ./path and path equivalent. (thanks @zhsso)
 ## v1.0.0 / 2014-08-15
 * [API] Remove AddWatch on Windows, use Add.
 * Improve documentation for exported identifiers. [#30](https://github.com/fsnotify/fsnotify/issues/30)
 * Minor updates based on feedback from golint.
 ## dev / 2014-07-09
 * Moved to [github.com/fsnotify/fsnotify](https://github.com/fsnotify/fsnotify).
 * Use os.NewSyscallError instead of returning errno (thanks @hariharan-uno)
 ## dev / 2014-07-04
 * kqueue: fix incorrect mutex used in Close()
 * Update example to demonstrate usage of Op.
 ## dev / 2014-06-28
 * [API] Don't set the Write Op for attribute notifications [#4](https://github.com/fsnotify/fsnotify/issues/4)
 * Fix for String() method on Event (thanks Alex Brainman)
 * Don't build on Plan 9 or Solaris (thanks @4ad)
 ## dev / 2014-06-21
 * Events channel of type Event rather than *Event.
 * [internal] use syscall constants directly for inotify and kqueue.
 * [internal] kqueue: rename events to kevents and fileEvent to event.
 ## dev / 2014-06-19
 * Go 1.3+ required on Windows (uses syscall.ERROR_MORE_DATA internally).
 * [internal] remove cookie from Event struct (unused).
 * [internal] Event struct has the same definition across every OS.
 * [internal] remove internal watch and removeWatch methods.
 ## dev / 2014-06-12
 * [API] Renamed Watch() to Add() and RemoveWatch() to Remove().
 * [API] Pluralized channel names: Events and Errors.
 * [API] Renamed FileEvent struct to Event.
 * [API] Op constants replace methods like IsCreate().
 ## dev / 2014-06-12
 * Fix data race on kevent buffer (thanks @tilaks) [#98](https://github.com/howeyc/fsnotify/pull/98)
 ## dev / 2014-05-23
 * [API] Remove current implementation of WatchFlags.
    * current implementation doesn't take advantage of OS for efficiency
    * provides little benefit over filtering events as they are received, but has  extra bookkeeping and mutexes
    * no tests for the current implementation
    * not fully implemented on Windows [#93](https://github.com/howeyc/fsnotify/issues/93#issuecomment-39285195)
 ## v0.9.3 / 2014-12-31
 * kqueue: cleanup internal watch before sending remove event [#51](https://github.com/fsnotify/fsnotify/issues/51)
 ## v0.9.2 / 2014-08-17
 * [Backport] Fix missing create events on macOS. [#14](https://github.com/fsnotify/fsnotify/issues/14) (thanks @zhsso)
 ## v0.9.1 / 2014-06-12
 * Fix data race on kevent buffer (thanks @tilaks) [#98](https://github.com/howeyc/fsnotify/pull/98)
 ## v0.9.0 / 2014-01-17
 * IsAttrib() for events that only concern a file's metadata [#79][] (thanks @abustany)
 * [Fix] kqueue: fix deadlock [#77][] (thanks @cespare)
 * [NOTICE] Development has moved to `code.google.com/p/go.exp/fsnotify` in preparation for inclusion in the Go standard library.
 ## v0.8.12 / 2013-11-13
 * [API] Remove FD_SET and friends from Linux adapter
 ## v0.8.11 / 2013-11-02
 * [Doc] Add Changelog [#72][] (thanks @nathany)
 * [Doc] Spotlight and double modify events on macOS [#62][] (reported by @paulhammond)
 ## v0.8.10 / 2013-10-19
 * [Fix] kqueue: remove file watches when parent directory is removed [#71][] (reported by @mdwhatcott)
 * [Fix] kqueue: race between Close and readEvents [#70][] (reported by @bernerdschaefer)
 * [Doc] specify OS-specific limits in README (thanks @debrando)
 ## v0.8.9 / 2013-09-08
 * [Doc] Contributing (thanks @nathany)
 * [Doc] update package path in example code [#63][] (thanks @paulhammond)
 * [Doc] GoCI badge in README (Linux only) [#60][]
 * [Doc] Cross-platform testing with Vagrant  [#59][] (thanks @nathany)
 ## v0.8.8 / 2013-06-17
 * [Fix] Windows: handle `ERROR_MORE_DATA` on Windows [#49][] (thanks @jbowtie)
 ## v0.8.7 / 2013-06-03
 * [API] Make syscall flags internal
 * [Fix] inotify: ignore event changes
 * [Fix] race in symlink test [#45][] (reported by @srid)
 * [Fix] tests on Windows
 * lower case error messages
 ## v0.8.6 / 2013-05-23
 * kqueue: Use EVT_ONLY flag on Darwin
 * [Doc] Update README with full example
 ## v0.8.5 / 2013-05-09
 * [Fix] inotify: allow monitoring of "broken" symlinks (thanks @tsg)
 ## v0.8.4 / 2013-04-07
 * [Fix] kqueue: watch all file events [#40][] (thanks @ChrisBuchholz)
 ## v0.8.3 / 2013-03-13
 * [Fix] inoitfy/kqueue memory leak [#36][] (reported by @nbkolchin)
 * [Fix] kqueue: use fsnFlags for watching a directory [#33][] (reported by @nbkolchin)
 ## v0.8.2 / 2013-02-07
 * [Doc] add Authors
 * [Fix] fix data races for map access [#29][] (thanks @fsouza)
 ## v0.8.1 / 2013-01-09
 * [Fix] Windows path separators
 * [Doc] BSD License
 ## v0.8.0 / 2012-11-09
 * kqueue: directory watching improvements (thanks @vmirage)
 * inotify: add `IN_MOVED_TO` [#25][] (requested by @cpisto)
 * [Fix] kqueue: deleting watched directory [#24][] (reported by @jakerr)
 ## v0.7.4 / 2012-10-09
 * [Fix] inotify: fixes from https://codereview.appspot.com/5418045/ (ugorji)
 * [Fix] kqueue: preserve watch flags when watching for delete [#21][] (reported by @robfig)
 * [Fix] kqueue: watch the directory even if it isn't a new watch (thanks @robfig)
 * [Fix] kqueue: modify after recreation of file
 ## v0.7.3 / 2012-09-27
 * [Fix] kqueue: watch with an existing folder inside the watched folder (thanks @vmirage)
 * [Fix] kqueue: no longer get duplicate CREATE events
 ## v0.7.2 / 2012-09-01
 * kqueue: events for created directories
 ## v0.7.1 / 2012-07-14
 * [Fix] for renaming files
 ## v0.7.0 / 2012-07-02
 * [Feature] FSNotify flags
 * [Fix] inotify: Added file name back to event path
 ## v0.6.0 / 2012-06-06
 * kqueue: watch files after directory created (thanks @tmc)
 ## v0.5.1 / 2012-05-22
 * [Fix] inotify: remove all watches before Close()
 ## v0.5.0 / 2012-05-03
 * [API] kqueue: return errors during watch instead of sending over channel
 * kqueue: match symlink behavior on Linux
 * inotify: add `DELETE_SELF` (requested by @taralx)
 * [Fix] kqueue: handle EINTR (reported by @robfig)
 * [Doc] Godoc example [#1][] (thanks @davecheney)
 ## v0.4.0 / 2012-03-30
 * Go 1 released: build with go tool
 * [Feature] Windows support using winfsnotify
 * Windows does not have attribute change notifications
 * Roll attribute notifications into IsModify
 ## v0.3.0 / 2012-02-19
 * kqueue: add files when watch directory
 ## v0.2.0 / 2011-12-30
 * update to latest Go weekly code
 ## v0.1.0 / 2011-10-19
 * kqueue: add watch on file creation to match inotify
 * kqueue: create file event
 * inotify: ignore `IN_IGNORED` events
 * event String()
 * linux: common FileEvent functions
 * initial commit
 [#79]: https://github.com/howeyc/fsnotify/pull/79
 [#77]: https://github.com/howeyc/fsnotify/pull/77
 [#72]: https://github.com/howeyc/fsnotify/issues/72
 [#71]: https://github.com/howeyc/fsnotify/issues/71
 [#70]: https://github.com/howeyc/fsnotify/issues/70
 [#63]: https://github.com/howeyc/fsnotify/issues/63
 [#62]: https://github.com/howeyc/fsnotify/issues/62
 [#60]: https://github.com/howeyc/fsnotify/issues/60
 [#59]: https://github.com/howeyc/fsnotify/issues/59
 [#49]: https://github.com/howeyc/fsnotify/issues/49
 [#45]: https://github.com/howeyc/fsnotify/issues/45
 [#40]: https://github.com/howeyc/fsnotify/issues/40
 [#36]: https://github.com/howeyc/fsnotify/issues/36
 [#33]: https://github.com/howeyc/fsnotify/issues/33
 [#29]: https://github.com/howeyc/fsnotify/issues/29
 [#25]: https://github.com/howeyc/fsnotify/issues/25
 [#24]: https://github.com/howeyc/fsnotify/issues/24
 [#21]: https://github.com/howeyc/fsnotify/issues/21
--- a/vendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md
+++ b/vendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md
@@ -0,0 +1,77 @@
 # Contributing
 ## Issues
 * Request features and report bugs using the [GitHub Issue Tracker](https://github.com/fsnotify/fsnotify/issues).
 * Please indicate the platform you are using fsnotify on.
 * A code example to reproduce the problem is appreciated.
 ## Pull Requests
 ### Contributor License Agreement
 fsnotify is derived from code in the [golang.org/x/exp](https://godoc.org/golang.org/x/exp) package and it may be included [in the standard library](https://github.com/fsnotify/fsnotify/issues/1) in the future. Therefore fsnotify carries the same [LICENSE](https://github.com/fsnotify/fsnotify/blob/master/LICENSE) as Go. Contributors retain their copyright, so you need to fill out a short form before we can accept your contribution: [Google Individual Contributor License Agreement](https://developers.google.com/open-source/cla/individual).
 Please indicate that you have signed the CLA in your pull request.
 ### How fsnotify is Developed
 * Development is done on feature branches.
 * Tests are run on BSD, Linux, macOS and Windows.
 * Pull requests are reviewed and [applied to master][am] using [hub][].
  * Maintainers may modify or squash commits rather than asking contributors to.
 * To issue a new release, the maintainers will:
  * Update the CHANGELOG
  * Tag a version, which will become available through gopkg.in.
 ### How to Fork
 For smooth sailing, always use the original import path. Installing with `go get` makes this easy. 
 1. Install from GitHub (`go get -u github.com/fsnotify/fsnotify`)
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Ensure everything works and the tests pass (see below)
 4. Commit your changes (`git commit -am 'Add some feature'`)
 Contribute upstream:
 1. Fork fsnotify on GitHub
 2. Add your remote (`git remote add fork git@github.com:mycompany/repo.git`)
 3. Push to the branch (`git push fork my-new-feature`)
 4. Create a new Pull Request on GitHub
 This workflow is [thoroughly explained by Katrina Owen](https://splice.com/blog/contributing-open-source-git-repositories-go/).
 ### Testing
 fsnotify uses build tags to compile different code on Linux, BSD, macOS, and Windows.
 Before doing a pull request, please do your best to test your changes on multiple platforms, and list which platforms you were able/unable to test on.
 To aid in cross-platform testing there is a Vagrantfile for Linux and BSD.
 * Install [Vagrant](http://www.vagrantup.com/) and [VirtualBox](https://www.virtualbox.org/)
 * Setup [Vagrant Gopher](https://github.com/nathany/vagrant-gopher) in your `src` folder.
 * Run `vagrant up` from the project folder. You can also setup just one box with `vagrant up linux` or `vagrant up bsd` (note: the BSD box doesn't support Windows hosts at this time, and NFS may prompt for your host OS password)
 * Once setup, you can run the test suite on a given OS with a single command `vagrant ssh linux -c 'cd fsnotify/fsnotify; go test'`.
 * When you're done, you will want to halt or destroy the Vagrant boxes.
 Notice: fsnotify file system events won't trigger in shared folders. The tests get around this limitation by using the /tmp directory.
 Right now there is no equivalent solution for Windows and macOS, but there are Windows VMs [freely available from Microsoft](http://www.modern.ie/en-us/virtualization-tools#downloads).
 ### Maintainers
 Help maintaining fsnotify is welcome. To be a maintainer:
 * Submit a pull request and sign the CLA as above.
 * You must be able to run the test suite on Mac, Windows, Linux and BSD.
 To keep master clean, the fsnotify project uses the "apply mail" workflow outlined in Nathaniel Talbott's post ["Merge pull request" Considered Harmful][am]. This requires installing [hub][].
 All code changes should be internal pull requests.
 Releases are tagged using [Semantic Versioning](http://semver.org/).
 [hub]: https://github.com/github/hub
 [am]: http://blog.spreedly.com/2014/06/24/merge-pull-request-considered-harmful/#.VGa5yZPF_Zs
--- a/vendor/github.com/fsnotify/fsnotify/LICENSE
+++ b/vendor/github.com/fsnotify/fsnotify/LICENSE
@@ -0,0 +1,28 @@
 Copyright (c) 2012 The Go Authors. All rights reserved.
 Copyright (c) 2012 fsnotify 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/fsnotify/fsnotify/README.md
+++ b/vendor/github.com/fsnotify/fsnotify/README.md
@@ -0,0 +1,79 @@
 # File system notifications for Go
 [![GoDoc](https://godoc.org/github.com/fsnotify/fsnotify?status.svg)](https://godoc.org/github.com/fsnotify/fsnotify) [![Go Report Card](https://goreportcard.com/badge/github.com/fsnotify/fsnotify)](https://goreportcard.com/report/github.com/fsnotify/fsnotify)
 fsnotify utilizes [golang.org/x/sys](https://godoc.org/golang.org/x/sys) rather than `syscall` from the standard library. Ensure you have the latest version installed by running:
 ```console
 go get -u golang.org/x/sys/...
 ```
 Cross platform: Windows, Linux, BSD and macOS.
 |Adapter   |OS        |Status    |
 |----------|----------|----------|
 |inotify   |Linux 2.6.27 or later, Android\*|Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify)|
 |kqueue    |BSD, macOS, iOS\*|Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify)|
 |ReadDirectoryChangesW|Windows|Supported [![Build status](https://ci.appveyor.com/api/projects/status/ivwjubaih4r0udeh/branch/master?svg=true)](https://ci.appveyor.com/project/NathanYoungman/fsnotify/branch/master)|
 |FSEvents  |macOS         |[Planned](https://github.com/fsnotify/fsnotify/issues/11)|
 |FEN       |Solaris 11    |[In Progress](https://github.com/fsnotify/fsnotify/issues/12)|
 |fanotify  |Linux 2.6.37+ | |
 |USN Journals |Windows    |[Maybe](https://github.com/fsnotify/fsnotify/issues/53)|
 |Polling   |*All*         |[Maybe](https://github.com/fsnotify/fsnotify/issues/9)|
 \* Android and iOS are untested.
 Please see [the documentation](https://godoc.org/github.com/fsnotify/fsnotify) and consult the [FAQ](#faq) for usage information.
 ## API stability
 fsnotify is a fork of [howeyc/fsnotify](https://godoc.org/github.com/howeyc/fsnotify) with a new API as of v1.0. The API is based on [this design document](http://goo.gl/MrYxyA). 
 All [releases](https://github.com/fsnotify/fsnotify/releases) are tagged based on [Semantic Versioning](http://semver.org/). Further API changes are [planned](https://github.com/fsnotify/fsnotify/milestones), and will be tagged with a new major revision number.
 Go 1.6 supports dependencies located in the `vendor/` folder. Unless you are creating a library, it is recommended that you copy fsnotify into `vendor/github.com/fsnotify/fsnotify` within your project, and likewise for `golang.org/x/sys`.
 ## Contributing
 Please refer to [CONTRIBUTING][] before opening an issue or pull request.
 ## Example
 See [example_test.go](https://github.com/fsnotify/fsnotify/blob/master/example_test.go).
 ## FAQ
 **When a file is moved to another directory is it still being watched?**
 No (it shouldn't be, unless you are watching where it was moved to).
 **When I watch a directory, are all subdirectories watched as well?**
 No, you must add watches for any directory you want to watch (a recursive watcher is on the roadmap [#18][]).
 **Do I have to watch the Error and Event channels in a separate goroutine?**
 As of now, yes. Looking into making this single-thread friendly (see [howeyc #7][#7])
 **Why am I receiving multiple events for the same file on OS X?**
 Spotlight indexing on OS X can result in multiple events (see [howeyc #62][#62]). A temporary workaround is to add your folder(s) to the *Spotlight Privacy settings* until we have a native FSEvents implementation (see [#11][]).
 **How many files can be watched at once?**
 There are OS-specific limits as to how many watches can be created:
 * Linux: /proc/sys/fs/inotify/max_user_watches contains the limit, reaching this limit results in a "no space left on device" error.
 * BSD / OSX: sysctl variables "kern.maxfiles" and "kern.maxfilesperproc", reaching these limits results in a "too many open files" error.
 [#62]: https://github.com/howeyc/fsnotify/issues/62
 [#18]: https://github.com/fsnotify/fsnotify/issues/18
 [#11]: https://github.com/fsnotify/fsnotify/issues/11
 [#7]: https://github.com/howeyc/fsnotify/issues/7
 [contributing]: https://github.com/fsnotify/fsnotify/blob/master/CONTRIBUTING.md
 ## Related Projects
 * [notify](https://github.com/rjeczalik/notify)
 * [fsevents](https://github.com/fsnotify/fsevents)
--- a/vendor/github.com/fsnotify/fsnotify/fen.go
+++ b/vendor/github.com/fsnotify/fsnotify/fen.go
@@ -0,0 +1,37 @@
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build solaris
 package fsnotify
 import (
 	"errors"
 )
 // Watcher watches a set of files, delivering events to a channel.
 type Watcher struct {
 	Events chan Event
 	Errors chan error
 }
 // NewWatcher establishes a new watcher with the underlying OS and begins waiting for events.
 func NewWatcher() (*Watcher, error) {
 	return nil, errors.New("FEN based watcher not yet supported for fsnotify\n")
 }
 // Close removes all watches and closes the events channel.
 func (w *Watcher) Close() error {
 	return nil
 }
 // Add starts watching the named file or directory (non-recursively).
 func (w *Watcher) Add(name string) error {
 	return nil
 }
 // Remove stops watching the the named file or directory (non-recursively).
 func (w *Watcher) Remove(name string) error {
 	return nil
 }
--- a/vendor/github.com/fsnotify/fsnotify/fsnotify.go
+++ b/vendor/github.com/fsnotify/fsnotify/fsnotify.go
@@ -0,0 +1,66 @@
 // Copyright 2012 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.
 // +build !plan9
 // Package fsnotify provides a platform-independent interface for file system notifications.
 package fsnotify
 import (
 	"bytes"
 	"errors"
 	"fmt"
 )
 // Event represents a single file system notification.
 type Event struct {
 	Name string // Relative path to the file or directory.
 	Op   Op     // File operation that triggered the event.
 }
 // Op describes a set of file operations.
 type Op uint32
 // These are the generalized file operations that can trigger a notification.
 const (
 	Create Op = 1 << iota
 	Write
 	Remove
 	Rename
 	Chmod
 )
 func (op Op) String() string {
 	// Use a buffer for efficient string concatenation
 	var buffer bytes.Buffer
 	if op&Create == Create {
 		buffer.WriteString("|CREATE")
 	}
 	if op&Remove == Remove {
 		buffer.WriteString("|REMOVE")
 	}
 	if op&Write == Write {
 		buffer.WriteString("|WRITE")
 	}
 	if op&Rename == Rename {
 		buffer.WriteString("|RENAME")
 	}
 	if op&Chmod == Chmod {
 		buffer.WriteString("|CHMOD")
 	}
 	if buffer.Len() == 0 {
 		return ""
 	}
 	return buffer.String()[1:] // Strip leading pipe
 }
 // String returns a string representation of the event in the form
 // "file: REMOVE|WRITE|..."
 func (e Event) String() string {
 	return fmt.Sprintf("%q: %s", e.Name, e.Op.String())
 }
 // Common errors that can be reported by a watcher
 var ErrEventOverflow = errors.New("fsnotify queue overflow")
--- a/vendor/github.com/fsnotify/fsnotify/inotify.go
+++ b/vendor/github.com/fsnotify/fsnotify/inotify.go
@@ -0,0 +1,337 @@
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build linux
 package fsnotify
 import (
 	"errors"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"strings"
 	"sync"
 	"unsafe"
 	"golang.org/x/sys/unix"
 )
 // Watcher watches a set of files, delivering events to a channel.
 type Watcher struct {
 	Events   chan Event
 	Errors   chan error
 	mu       sync.Mutex // Map access
 	fd       int
 	poller   *fdPoller
 	watches  map[string]*watch // Map of inotify watches (key: path)
 	paths    map[int]string    // Map of watched paths (key: watch descriptor)
 	done     chan struct{}     // Channel for sending a "quit message" to the reader goroutine
 	doneResp chan struct{}     // Channel to respond to Close
 }
 // NewWatcher establishes a new watcher with the underlying OS and begins waiting for events.
 func NewWatcher() (*Watcher, error) {
 	// Create inotify fd
 	fd, errno := unix.InotifyInit1(unix.IN_CLOEXEC)
 	if fd == -1 {
 		return nil, errno
 	}
 	// Create epoll
 	poller, err := newFdPoller(fd)
 	if err != nil {
 		unix.Close(fd)
 		return nil, err
 	}
 	w := &Watcher{
 		fd:       fd,
 		poller:   poller,
 		watches:  make(map[string]*watch),
 		paths:    make(map[int]string),
 		Events:   make(chan Event),
 		Errors:   make(chan error),
 		done:     make(chan struct{}),
 		doneResp: make(chan struct{}),
 	}
 	go w.readEvents()
 	return w, nil
 }
 func (w *Watcher) isClosed() bool {
 	select {
 	case <-w.done:
 		return true
 	default:
 		return false
 	}
 }
 // Close removes all watches and closes the events channel.
 func (w *Watcher) Close() error {
 	if w.isClosed() {
 		return nil
 	}
 	// Send 'close' signal to goroutine, and set the Watcher to closed.
 	close(w.done)
 	// Wake up goroutine
 	w.poller.wake()
 	// Wait for goroutine to close
 	<-w.doneResp
 	return nil
 }
 // Add starts watching the named file or directory (non-recursively).
 func (w *Watcher) Add(name string) error {
 	name = filepath.Clean(name)
 	if w.isClosed() {
 		return errors.New("inotify instance already closed")
 	}
 	const agnosticEvents = unix.IN_MOVED_TO | unix.IN_MOVED_FROM |
 		unix.IN_CREATE | unix.IN_ATTRIB | unix.IN_MODIFY |
 		unix.IN_MOVE_SELF | unix.IN_DELETE | unix.IN_DELETE_SELF
 	var flags uint32 = agnosticEvents
 	w.mu.Lock()
 	defer w.mu.Unlock()
 	watchEntry := w.watches[name]
 	if watchEntry != nil {
 		flags |= watchEntry.flags | unix.IN_MASK_ADD
 	}
 	wd, errno := unix.InotifyAddWatch(w.fd, name, flags)
 	if wd == -1 {
 		return errno
 	}
 	if watchEntry == nil {
 		w.watches[name] = &watch{wd: uint32(wd), flags: flags}
 		w.paths[wd] = name
 	} else {
 		watchEntry.wd = uint32(wd)
 		watchEntry.flags = flags
 	}
 	return nil
 }
 // Remove stops watching the named file or directory (non-recursively).
 func (w *Watcher) Remove(name string) error {
 	name = filepath.Clean(name)
 	// Fetch the watch.
 	w.mu.Lock()
 	defer w.mu.Unlock()
 	watch, ok := w.watches[name]
 	// Remove it from inotify.
 	if !ok {
 		return fmt.Errorf("can't remove non-existent inotify watch for: %s", name)
 	}
 	// We successfully removed the watch if InotifyRmWatch doesn't return an
 	// error, we need to clean up our internal state to ensure it matches
 	// inotify's kernel state.
 	delete(w.paths, int(watch.wd))
 	delete(w.watches, name)
 	// inotify_rm_watch will return EINVAL if the file has been deleted;
 	// the inotify will already have been removed.
 	// watches and pathes are deleted in ignoreLinux() implicitly and asynchronously
 	// by calling inotify_rm_watch() below. e.g. readEvents() goroutine receives IN_IGNORE
 	// so that EINVAL means that the wd is being rm_watch()ed or its file removed
 	// by another thread and we have not received IN_IGNORE event.
 	success, errno := unix.InotifyRmWatch(w.fd, watch.wd)
 	if success == -1 {
 		// TODO: Perhaps it's not helpful to return an error here in every case.
 		// the only two possible errors are:
 		// EBADF, which happens when w.fd is not a valid file descriptor of any kind.
 		// EINVAL, which is when fd is not an inotify descriptor or wd is not a valid watch descriptor.
 		// Watch descriptors are invalidated when they are removed explicitly or implicitly;
 		// explicitly by inotify_rm_watch, implicitly when the file they are watching is deleted.
 		return errno
 	}
 	return nil
 }
 type watch struct {
 	wd    uint32 // Watch descriptor (as returned by the inotify_add_watch() syscall)
 	flags uint32 // inotify flags of this watch (see inotify(7) for the list of valid flags)
 }
 // readEvents reads from the inotify file descriptor, converts the
 // received events into Event objects and sends them via the Events channel
 func (w *Watcher) readEvents() {
 	var (
 		buf   [unix.SizeofInotifyEvent * 4096]byte // Buffer for a maximum of 4096 raw events
 		n     int                                  // Number of bytes read with read()
 		errno error                                // Syscall errno
 		ok    bool                                 // For poller.wait
 	)
 	defer close(w.doneResp)
 	defer close(w.Errors)
 	defer close(w.Events)
 	defer unix.Close(w.fd)
 	defer w.poller.close()
 	for {
 		// See if we have been closed.
 		if w.isClosed() {
 			return
 		}
 		ok, errno = w.poller.wait()
 		if errno != nil {
 			select {
 			case w.Errors <- errno:
 			case <-w.done:
 				return
 			}
 			continue
 		}
 		if !ok {
 			continue
 		}
 		n, errno = unix.Read(w.fd, buf[:])
 		// If a signal interrupted execution, see if we've been asked to close, and try again.
 		// http://man7.org/linux/man-pages/man7/signal.7.html :
 		// "Before Linux 3.8, reads from an inotify(7) file descriptor were not restartable"
 		if errno == unix.EINTR {
 			continue
 		}
 		// unix.Read might have been woken up by Close. If so, we're done.
 		if w.isClosed() {
 			return
 		}
 		if n < unix.SizeofInotifyEvent {
 			var err error
 			if n == 0 {
 				// If EOF is received. This should really never happen.
 				err = io.EOF
 			} else if n < 0 {
 				// If an error occurred while reading.
 				err = errno
 			} else {
 				// Read was too short.
 				err = errors.New("notify: short read in readEvents()")
 			}
 			select {
 			case w.Errors <- err:
 			case <-w.done:
 				return
 			}
 			continue
 		}
 		var offset uint32
 		// We don't know how many events we just read into the buffer
 		// While the offset points to at least one whole event...
 		for offset <= uint32(n-unix.SizeofInotifyEvent) {
 			// Point "raw" to the event in the buffer
 			raw := (*unix.InotifyEvent)(unsafe.Pointer(&buf[offset]))
 			mask := uint32(raw.Mask)
 			nameLen := uint32(raw.Len)
 			if mask&unix.IN_Q_OVERFLOW != 0 {
 				select {
 				case w.Errors <- ErrEventOverflow:
 				case <-w.done:
 					return
 				}
 			}
 			// If the event happened to the watched directory or the watched file, the kernel
 			// doesn't append the filename to the event, but we would like to always fill the
 			// the "Name" field with a valid filename. We retrieve the path of the watch from
 			// the "paths" map.
 			w.mu.Lock()
 			name, ok := w.paths[int(raw.Wd)]
 			// IN_DELETE_SELF occurs when the file/directory being watched is removed.
 			// This is a sign to clean up the maps, otherwise we are no longer in sync
 			// with the inotify kernel state which has already deleted the watch
 			// automatically.
 			if ok && mask&unix.IN_DELETE_SELF == unix.IN_DELETE_SELF {
 				delete(w.paths, int(raw.Wd))
 				delete(w.watches, name)
 			}
 			w.mu.Unlock()
 			if nameLen > 0 {
 				// Point "bytes" at the first byte of the filename
 				bytes := (*[unix.PathMax]byte)(unsafe.Pointer(&buf[offset+unix.SizeofInotifyEvent]))
 				// The filename is padded with NULL bytes. TrimRight() gets rid of those.
 				name += "/" + strings.TrimRight(string(bytes[0:nameLen]), "\000")
 			}
 			event := newEvent(name, mask)
 			// Send the events that are not ignored on the events channel
 			if !event.ignoreLinux(mask) {
 				select {
 				case w.Events <- event:
 				case <-w.done:
 					return
 				}
 			}
 			// Move to the next event in the buffer
 			offset += unix.SizeofInotifyEvent + nameLen
 		}
 	}
 }
 // Certain types of events can be "ignored" and not sent over the Events
 // channel. Such as events marked ignore by the kernel, or MODIFY events
 // against files that do not exist.
 func (e *Event) ignoreLinux(mask uint32) bool {
 	// Ignore anything the inotify API says to ignore
 	if mask&unix.IN_IGNORED == unix.IN_IGNORED {
 		return true
 	}
 	// If the event is not a DELETE or RENAME, the file must exist.
 	// Otherwise the event is ignored.
 	// *Note*: this was put in place because it was seen that a MODIFY
 	// event was sent after the DELETE. This ignores that MODIFY and
 	// assumes a DELETE will come or has come if the file doesn't exist.
 	if !(e.Op&Remove == Remove || e.Op&Rename == Rename) {
 		_, statErr := os.Lstat(e.Name)
 		return os.IsNotExist(statErr)
 	}
 	return false
 }
 // newEvent returns an platform-independent Event based on an inotify mask.
 func newEvent(name string, mask uint32) Event {
 	e := Event{Name: name}
 	if mask&unix.IN_CREATE == unix.IN_CREATE || mask&unix.IN_MOVED_TO == unix.IN_MOVED_TO {
 		e.Op |= Create
 	}
 	if mask&unix.IN_DELETE_SELF == unix.IN_DELETE_SELF || mask&unix.IN_DELETE == unix.IN_DELETE {
 		e.Op |= Remove
 	}
 	if mask&unix.IN_MODIFY == unix.IN_MODIFY {
 		e.Op |= Write
 	}
 	if mask&unix.IN_MOVE_SELF == unix.IN_MOVE_SELF || mask&unix.IN_MOVED_FROM == unix.IN_MOVED_FROM {
 		e.Op |= Rename
 	}
 	if mask&unix.IN_ATTRIB == unix.IN_ATTRIB {
 		e.Op |= Chmod
 	}
 	return e
 }
--- a/vendor/github.com/fsnotify/fsnotify/inotify_poller.go
+++ b/vendor/github.com/fsnotify/fsnotify/inotify_poller.go
@@ -0,0 +1,187 @@
 // Copyright 2015 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.
 // +build linux
 package fsnotify
 import (
 	"errors"
 	"golang.org/x/sys/unix"
 )
 type fdPoller struct {
 	fd   int    // File descriptor (as returned by the inotify_init() syscall)
 	epfd int    // Epoll file descriptor
 	pipe [2]int // Pipe for waking up
 }
 func emptyPoller(fd int) *fdPoller {
 	poller := new(fdPoller)
 	poller.fd = fd
 	poller.epfd = -1
 	poller.pipe[0] = -1
 	poller.pipe[1] = -1
 	return poller
 }
 // Create a new inotify poller.
 // This creates an inotify handler, and an epoll handler.
 func newFdPoller(fd int) (*fdPoller, error) {
 	var errno error
 	poller := emptyPoller(fd)
 	defer func() {
 		if errno != nil {
 			poller.close()
 		}
 	}()
 	poller.fd = fd
 	// Create epoll fd
 	poller.epfd, errno = unix.EpollCreate1(0)
 	if poller.epfd == -1 {
 		return nil, errno
 	}
 	// Create pipe; pipe[0] is the read end, pipe[1] the write end.
 	errno = unix.Pipe2(poller.pipe[:], unix.O_NONBLOCK)
 	if errno != nil {
 		return nil, errno
 	}
 	// Register inotify fd with epoll
 	event := unix.EpollEvent{
 		Fd:     int32(poller.fd),
 		Events: unix.EPOLLIN,
 	}
 	errno = unix.EpollCtl(poller.epfd, unix.EPOLL_CTL_ADD, poller.fd, &event)
 	if errno != nil {
 		return nil, errno
 	}
 	// Register pipe fd with epoll
 	event = unix.EpollEvent{
 		Fd:     int32(poller.pipe[0]),
 		Events: unix.EPOLLIN,
 	}
 	errno = unix.EpollCtl(poller.epfd, unix.EPOLL_CTL_ADD, poller.pipe[0], &event)
 	if errno != nil {
 		return nil, errno
 	}
 	return poller, nil
 }
 // Wait using epoll.
 // Returns true if something is ready to be read,
 // false if there is not.
 func (poller *fdPoller) wait() (bool, error) {
 	// 3 possible events per fd, and 2 fds, makes a maximum of 6 events.
 	// I don't know whether epoll_wait returns the number of events returned,
 	// or the total number of events ready.
 	// I decided to catch both by making the buffer one larger than the maximum.
 	events := make([]unix.EpollEvent, 7)
 	for {
 		n, errno := unix.EpollWait(poller.epfd, events, -1)
 		if n == -1 {
 			if errno == unix.EINTR {
 				continue
 			}
 			return false, errno
 		}
 		if n == 0 {
 			// If there are no events, try again.
 			continue
 		}
 		if n > 6 {
 			// This should never happen. More events were returned than should be possible.
 			return false, errors.New("epoll_wait returned more events than I know what to do with")
 		}
 		ready := events[:n]
 		epollhup := false
 		epollerr := false
 		epollin := false
 		for _, event := range ready {
 			if event.Fd == int32(poller.fd) {
 				if event.Events&unix.EPOLLHUP != 0 {
 					// This should not happen, but if it does, treat it as a wakeup.
 					epollhup = true
 				}
 				if event.Events&unix.EPOLLERR != 0 {
 					// If an error is waiting on the file descriptor, we should pretend
 					// something is ready to read, and let unix.Read pick up the error.
 					epollerr = true
 				}
 				if event.Events&unix.EPOLLIN != 0 {
 					// There is data to read.
 					epollin = true
 				}
 			}
 			if event.Fd == int32(poller.pipe[0]) {
 				if event.Events&unix.EPOLLHUP != 0 {
 					// Write pipe descriptor was closed, by us. This means we're closing down the
 					// watcher, and we should wake up.
 				}
 				if event.Events&unix.EPOLLERR != 0 {
 					// If an error is waiting on the pipe file descriptor.
 					// This is an absolute mystery, and should never ever happen.
 					return false, errors.New("Error on the pipe descriptor.")
 				}
 				if event.Events&unix.EPOLLIN != 0 {
 					// This is a regular wakeup, so we have to clear the buffer.
 					err := poller.clearWake()
 					if err != nil {
 						return false, err
 					}
 				}
 			}
 		}
 		if epollhup || epollerr || epollin {
 			return true, nil
 		}
 		return false, nil
 	}
 }
 // Close the write end of the poller.
 func (poller *fdPoller) wake() error {
 	buf := make([]byte, 1)
 	n, errno := unix.Write(poller.pipe[1], buf)
 	if n == -1 {
 		if errno == unix.EAGAIN {
 			// Buffer is full, poller will wake.
 			return nil
 		}
 		return errno
 	}
 	return nil
 }
 func (poller *fdPoller) clearWake() error {
 	// You have to be woken up a LOT in order to get to 100!
 	buf := make([]byte, 100)
 	n, errno := unix.Read(poller.pipe[0], buf)
 	if n == -1 {
 		if errno == unix.EAGAIN {
 			// Buffer is empty, someone else cleared our wake.
 			return nil
 		}
 		return errno
 	}
 	return nil
 }
 // Close all poller file descriptors, but not the one passed to it.
 func (poller *fdPoller) close() {
 	if poller.pipe[1] != -1 {
 		unix.Close(poller.pipe[1])
 	}
 	if poller.pipe[0] != -1 {
 		unix.Close(poller.pipe[0])
 	}
 	if poller.epfd != -1 {
 		unix.Close(poller.epfd)
 	}
 }
--- a/vendor/github.com/fsnotify/fsnotify/kqueue.go
+++ b/vendor/github.com/fsnotify/fsnotify/kqueue.go
@@ -0,0 +1,521 @@
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build freebsd openbsd netbsd dragonfly darwin
 package fsnotify
 import (
 	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"sync"
 	"time"
 	"golang.org/x/sys/unix"
 )
 // Watcher watches a set of files, delivering events to a channel.
 type Watcher struct {
 	Events chan Event
 	Errors chan error
 	done   chan struct{} // Channel for sending a "quit message" to the reader goroutine
 	kq int // File descriptor (as returned by the kqueue() syscall).
 	mu              sync.Mutex        // Protects access to watcher data
 	watches         map[string]int    // Map of watched file descriptors (key: path).
 	externalWatches map[string]bool   // Map of watches added by user of the library.
 	dirFlags        map[string]uint32 // Map of watched directories to fflags used in kqueue.
 	paths           map[int]pathInfo  // Map file descriptors to path names for processing kqueue events.
 	fileExists      map[string]bool   // Keep track of if we know this file exists (to stop duplicate create events).
 	isClosed        bool              // Set to true when Close() is first called
 }
 type pathInfo struct {
 	name  string
 	isDir bool
 }
 // NewWatcher establishes a new watcher with the underlying OS and begins waiting for events.
 func NewWatcher() (*Watcher, error) {
 	kq, err := kqueue()
 	if err != nil {
 		return nil, err
 	}
 	w := &Watcher{
 		kq:              kq,
 		watches:         make(map[string]int),
 		dirFlags:        make(map[string]uint32),
 		paths:           make(map[int]pathInfo),
 		fileExists:      make(map[string]bool),
 		externalWatches: make(map[string]bool),
 		Events:          make(chan Event),
 		Errors:          make(chan error),
 		done:            make(chan struct{}),
 	}
 	go w.readEvents()
 	return w, nil
 }
 // Close removes all watches and closes the events channel.
 func (w *Watcher) Close() error {
 	w.mu.Lock()
 	if w.isClosed {
 		w.mu.Unlock()
 		return nil
 	}
 	w.isClosed = true
 	// copy paths to remove while locked
 	var pathsToRemove = make([]string, 0, len(w.watches))
 	for name := range w.watches {
 		pathsToRemove = append(pathsToRemove, name)
 	}
 	w.mu.Unlock()
 	// unlock before calling Remove, which also locks
 	for _, name := range pathsToRemove {
 		w.Remove(name)
 	}
 	// send a "quit" message to the reader goroutine
 	close(w.done)
 	return nil
 }
 // Add starts watching the named file or directory (non-recursively).
 func (w *Watcher) Add(name string) error {
 	w.mu.Lock()
 	w.externalWatches[name] = true
 	w.mu.Unlock()
 	_, err := w.addWatch(name, noteAllEvents)
 	return err
 }
 // Remove stops watching the the named file or directory (non-recursively).
 func (w *Watcher) Remove(name string) error {
 	name = filepath.Clean(name)
 	w.mu.Lock()
 	watchfd, ok := w.watches[name]
 	w.mu.Unlock()
 	if !ok {
 		return fmt.Errorf("can't remove non-existent kevent watch for: %s", name)
 	}
 	const registerRemove = unix.EV_DELETE
 	if err := register(w.kq, []int{watchfd}, registerRemove, 0); err != nil {
 		return err
 	}
 	unix.Close(watchfd)
 	w.mu.Lock()
 	isDir := w.paths[watchfd].isDir
 	delete(w.watches, name)
 	delete(w.paths, watchfd)
 	delete(w.dirFlags, name)
 	w.mu.Unlock()
 	// Find all watched paths that are in this directory that are not external.
 	if isDir {
 		var pathsToRemove []string
 		w.mu.Lock()
 		for _, path := range w.paths {
 			wdir, _ := filepath.Split(path.name)
 			if filepath.Clean(wdir) == name {
 				if !w.externalWatches[path.name] {
 					pathsToRemove = append(pathsToRemove, path.name)
 				}
 			}
 		}
 		w.mu.Unlock()
 		for _, name := range pathsToRemove {
 			// Since these are internal, not much sense in propagating error
 			// to the user, as that will just confuse them with an error about
 			// a path they did not explicitly watch themselves.
 			w.Remove(name)
 		}
 	}
 	return nil
 }
 // Watch all events (except NOTE_EXTEND, NOTE_LINK, NOTE_REVOKE)
 const noteAllEvents = unix.NOTE_DELETE | unix.NOTE_WRITE | unix.NOTE_ATTRIB | unix.NOTE_RENAME
 // keventWaitTime to block on each read from kevent
 var keventWaitTime = durationToTimespec(100 * time.Millisecond)
 // addWatch adds name to the watched file set.
 // The flags are interpreted as described in kevent(2).
 // Returns the real path to the file which was added, if any, which may be different from the one passed in the case of symlinks.
 func (w *Watcher) addWatch(name string, flags uint32) (string, error) {
 	var isDir bool
 	// Make ./name and name equivalent
 	name = filepath.Clean(name)
 	w.mu.Lock()
 	if w.isClosed {
 		w.mu.Unlock()
 		return "", errors.New("kevent instance already closed")
 	}
 	watchfd, alreadyWatching := w.watches[name]
 	// We already have a watch, but we can still override flags.
 	if alreadyWatching {
 		isDir = w.paths[watchfd].isDir
 	}
 	w.mu.Unlock()
 	if !alreadyWatching {
 		fi, err := os.Lstat(name)
 		if err != nil {
 			return "", err
 		}
 		// Don't watch sockets.
 		if fi.Mode()&os.ModeSocket == os.ModeSocket {
 			return "", nil
 		}
 		// Don't watch named pipes.
 		if fi.Mode()&os.ModeNamedPipe == os.ModeNamedPipe {
 			return "", nil
 		}
 		// Follow Symlinks
 		// Unfortunately, Linux can add bogus symlinks to watch list without
 		// issue, and Windows can't do symlinks period (AFAIK). To  maintain
 		// consistency, we will act like everything is fine. There will simply
 		// be no file events for broken symlinks.
 		// Hence the returns of nil on errors.
 		if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
 			name, err = filepath.EvalSymlinks(name)
 			if err != nil {
 				return "", nil
 			}
 			w.mu.Lock()
 			_, alreadyWatching = w.watches[name]
 			w.mu.Unlock()
 			if alreadyWatching {
 				return name, nil
 			}
 			fi, err = os.Lstat(name)
 			if err != nil {
 				return "", nil
 			}
 		}
 		watchfd, err = unix.Open(name, openMode, 0700)
 		if watchfd == -1 {
 			return "", err
 		}
 		isDir = fi.IsDir()
 	}
 	const registerAdd = unix.EV_ADD | unix.EV_CLEAR | unix.EV_ENABLE
 	if err := register(w.kq, []int{watchfd}, registerAdd, flags); err != nil {
 		unix.Close(watchfd)
 		return "", err
 	}
 	if !alreadyWatching {
 		w.mu.Lock()
 		w.watches[name] = watchfd
 		w.paths[watchfd] = pathInfo{name: name, isDir: isDir}
 		w.mu.Unlock()
 	}
 	if isDir {
 		// Watch the directory if it has not been watched before,
 		// or if it was watched before, but perhaps only a NOTE_DELETE (watchDirectoryFiles)
 		w.mu.Lock()
 		watchDir := (flags&unix.NOTE_WRITE) == unix.NOTE_WRITE &&
 			(!alreadyWatching || (w.dirFlags[name]&unix.NOTE_WRITE) != unix.NOTE_WRITE)
 		// Store flags so this watch can be updated later
 		w.dirFlags[name] = flags
 		w.mu.Unlock()
 		if watchDir {
 			if err := w.watchDirectoryFiles(name); err != nil {
 				return "", err
 			}
 		}
 	}
 	return name, nil
 }
 // readEvents reads from kqueue and converts the received kevents into
 // Event values that it sends down the Events channel.
 func (w *Watcher) readEvents() {
 	eventBuffer := make([]unix.Kevent_t, 10)
 loop:
 	for {
 		// See if there is a message on the "done" channel
 		select {
 		case <-w.done:
 			break loop
 		default:
 		}
 		// Get new events
 		kevents, err := read(w.kq, eventBuffer, &keventWaitTime)
 		// EINTR is okay, the syscall was interrupted before timeout expired.
 		if err != nil && err != unix.EINTR {
 			select {
 			case w.Errors <- err:
 			case <-w.done:
 				break loop
 			}
 			continue
 		}
 		// Flush the events we received to the Events channel
 		for len(kevents) > 0 {
 			kevent := &kevents[0]
 			watchfd := int(kevent.Ident)
 			mask := uint32(kevent.Fflags)
 			w.mu.Lock()
 			path := w.paths[watchfd]
 			w.mu.Unlock()
 			event := newEvent(path.name, mask)
 			if path.isDir && !(event.Op&Remove == Remove) {
 				// Double check to make sure the directory exists. This can happen when
 				// we do a rm -fr on a recursively watched folders and we receive a
 				// modification event first but the folder has been deleted and later
 				// receive the delete event
 				if _, err := os.Lstat(event.Name); os.IsNotExist(err) {
 					// mark is as delete event
 					event.Op |= Remove
 				}
 			}
 			if event.Op&Rename == Rename || event.Op&Remove == Remove {
 				w.Remove(event.Name)
 				w.mu.Lock()
 				delete(w.fileExists, event.Name)
 				w.mu.Unlock()
 			}
 			if path.isDir && event.Op&Write == Write && !(event.Op&Remove == Remove) {
 				w.sendDirectoryChangeEvents(event.Name)
 			} else {
 				// Send the event on the Events channel.
 				select {
 				case w.Events <- event:
 				case <-w.done:
 					break loop
 				}
 			}
 			if event.Op&Remove == Remove {
 				// Look for a file that may have overwritten this.
 				// For example, mv f1 f2 will delete f2, then create f2.
 				if path.isDir {
 					fileDir := filepath.Clean(event.Name)
 					w.mu.Lock()
 					_, found := w.watches[fileDir]
 					w.mu.Unlock()
 					if found {
 						// make sure the directory exists before we watch for changes. When we
 						// do a recursive watch and perform rm -fr, the parent directory might
 						// have gone missing, ignore the missing directory and let the
 						// upcoming delete event remove the watch from the parent directory.
 						if _, err := os.Lstat(fileDir); err == nil {
 							w.sendDirectoryChangeEvents(fileDir)
 						}
 					}
 				} else {
 					filePath := filepath.Clean(event.Name)
 					if fileInfo, err := os.Lstat(filePath); err == nil {
 						w.sendFileCreatedEventIfNew(filePath, fileInfo)
 					}
 				}
 			}
 			// Move to next event
 			kevents = kevents[1:]
 		}
 	}
 	// cleanup
 	err := unix.Close(w.kq)
 	if err != nil {
 		// only way the previous loop breaks is if w.done was closed so we need to async send to w.Errors.
 		select {
 		case w.Errors <- err:
 		default:
 		}
 	}
 	close(w.Events)
 	close(w.Errors)
 }
 // newEvent returns an platform-independent Event based on kqueue Fflags.
 func newEvent(name string, mask uint32) Event {
 	e := Event{Name: name}
 	if mask&unix.NOTE_DELETE == unix.NOTE_DELETE {
 		e.Op |= Remove
 	}
 	if mask&unix.NOTE_WRITE == unix.NOTE_WRITE {
 		e.Op |= Write
 	}
 	if mask&unix.NOTE_RENAME == unix.NOTE_RENAME {
 		e.Op |= Rename
 	}
 	if mask&unix.NOTE_ATTRIB == unix.NOTE_ATTRIB {
 		e.Op |= Chmod
 	}
 	return e
 }
 func newCreateEvent(name string) Event {
 	return Event{Name: name, Op: Create}
 }
 // watchDirectoryFiles to mimic inotify when adding a watch on a directory
 func (w *Watcher) watchDirectoryFiles(dirPath string) error {
 	// Get all files
 	files, err := ioutil.ReadDir(dirPath)
 	if err != nil {
 		return err
 	}
 	for _, fileInfo := range files {
 		filePath := filepath.Join(dirPath, fileInfo.Name())
 		filePath, err = w.internalWatch(filePath, fileInfo)
 		if err != nil {
 			return err
 		}
 		w.mu.Lock()
 		w.fileExists[filePath] = true
 		w.mu.Unlock()
 	}
 	return nil
 }
 // sendDirectoryEvents searches the directory for newly created files
 // and sends them over the event channel. This functionality is to have
 // the BSD version of fsnotify match Linux inotify which provides a
 // create event for files created in a watched directory.
 func (w *Watcher) sendDirectoryChangeEvents(dirPath string) {
 	// Get all files
 	files, err := ioutil.ReadDir(dirPath)
 	if err != nil {
 		select {
 		case w.Errors <- err:
 		case <-w.done:
 			return
 		}
 	}
 	// Search for new files
 	for _, fileInfo := range files {
 		filePath := filepath.Join(dirPath, fileInfo.Name())
 		err := w.sendFileCreatedEventIfNew(filePath, fileInfo)
 		if err != nil {
 			return
 		}
 	}
 }
 // sendFileCreatedEvent sends a create event if the file isn't already being tracked.
 func (w *Watcher) sendFileCreatedEventIfNew(filePath string, fileInfo os.FileInfo) (err error) {
 	w.mu.Lock()
 	_, doesExist := w.fileExists[filePath]
 	w.mu.Unlock()
 	if !doesExist {
 		// Send create event
 		select {
 		case w.Events <- newCreateEvent(filePath):
 		case <-w.done:
 			return
 		}
 	}
 	// like watchDirectoryFiles (but without doing another ReadDir)
 	filePath, err = w.internalWatch(filePath, fileInfo)
 	if err != nil {
 		return err
 	}
 	w.mu.Lock()
 	w.fileExists[filePath] = true
 	w.mu.Unlock()
 	return nil
 }
 func (w *Watcher) internalWatch(name string, fileInfo os.FileInfo) (string, error) {
 	if fileInfo.IsDir() {
 		// mimic Linux providing delete events for subdirectories
 		// but preserve the flags used if currently watching subdirectory
 		w.mu.Lock()
 		flags := w.dirFlags[name]
 		w.mu.Unlock()
 		flags |= unix.NOTE_DELETE | unix.NOTE_RENAME
 		return w.addWatch(name, flags)
 	}
 	// watch file to mimic Linux inotify
 	return w.addWatch(name, noteAllEvents)
 }
 // kqueue creates a new kernel event queue and returns a descriptor.
 func kqueue() (kq int, err error) {
 	kq, err = unix.Kqueue()
 	if kq == -1 {
 		return kq, err
 	}
 	return kq, nil
 }
 // register events with the queue
 func register(kq int, fds []int, flags int, fflags uint32) error {
 	changes := make([]unix.Kevent_t, len(fds))
 	for i, fd := range fds {
 		// SetKevent converts int to the platform-specific types:
 		unix.SetKevent(&changes[i], fd, unix.EVFILT_VNODE, flags)
 		changes[i].Fflags = fflags
 	}
 	// register the events
 	success, err := unix.Kevent(kq, changes, nil, nil)
 	if success == -1 {
 		return err
 	}
 	return nil
 }
 // read retrieves pending events, or waits until an event occurs.
 // A timeout of nil blocks indefinitely, while 0 polls the queue.
 func read(kq int, events []unix.Kevent_t, timeout *unix.Timespec) ([]unix.Kevent_t, error) {
 	n, err := unix.Kevent(kq, nil, events, timeout)
 	if err != nil {
 		return nil, err
 	}
 	return events[0:n], nil
 }
 // durationToTimespec prepares a timeout value
 func durationToTimespec(d time.Duration) unix.Timespec {
 	return unix.NsecToTimespec(d.Nanoseconds())
 }
--- a/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go
+++ b/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go
@@ -0,0 +1,11 @@
 // Copyright 2013 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.
 // +build freebsd openbsd netbsd dragonfly
 package fsnotify
 import "golang.org/x/sys/unix"
 const openMode = unix.O_NONBLOCK | unix.O_RDONLY
--- a/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go
+++ b/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go
@@ -0,0 +1,12 @@
 // Copyright 2013 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.
 // +build darwin
 package fsnotify
 import "golang.org/x/sys/unix"
 // note: this constant is not defined on BSD
 const openMode = unix.O_EVTONLY
--- a/vendor/github.com/fsnotify/fsnotify/windows.go
+++ b/vendor/github.com/fsnotify/fsnotify/windows.go
@@ -0,0 +1,561 @@
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build windows
 package fsnotify
 import (
 	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"runtime"
 	"sync"
 	"syscall"
 	"unsafe"
 )
 // Watcher watches a set of files, delivering events to a channel.
 type Watcher struct {
 	Events   chan Event
 	Errors   chan error
 	isClosed bool           // Set to true when Close() is first called
 	mu       sync.Mutex     // Map access
 	port     syscall.Handle // Handle to completion port
 	watches  watchMap       // Map of watches (key: i-number)
 	input    chan *input    // Inputs to the reader are sent on this channel
 	quit     chan chan<- error
 }
 // NewWatcher establishes a new watcher with the underlying OS and begins waiting for events.
 func NewWatcher() (*Watcher, error) {
 	port, e := syscall.CreateIoCompletionPort(syscall.InvalidHandle, 0, 0, 0)
 	if e != nil {
 		return nil, os.NewSyscallError("CreateIoCompletionPort", e)
 	}
 	w := &Watcher{
 		port:    port,
 		watches: make(watchMap),
 		input:   make(chan *input, 1),
 		Events:  make(chan Event, 50),
 		Errors:  make(chan error),
 		quit:    make(chan chan<- error, 1),
 	}
 	go w.readEvents()
 	return w, nil
 }
 // Close removes all watches and closes the events channel.
 func (w *Watcher) Close() error {
 	if w.isClosed {
 		return nil
 	}
 	w.isClosed = true
 	// Send "quit" message to the reader goroutine
 	ch := make(chan error)
 	w.quit <- ch
 	if err := w.wakeupReader(); err != nil {
 		return err
 	}
 	return <-ch
 }
 // Add starts watching the named file or directory (non-recursively).
 func (w *Watcher) Add(name string) error {
 	if w.isClosed {
 		return errors.New("watcher already closed")
 	}
 	in := &input{
 		op:    opAddWatch,
 		path:  filepath.Clean(name),
 		flags: sysFSALLEVENTS,
 		reply: make(chan error),
 	}
 	w.input <- in
 	if err := w.wakeupReader(); err != nil {
 		return err
 	}
 	return <-in.reply
 }
 // Remove stops watching the the named file or directory (non-recursively).
 func (w *Watcher) Remove(name string) error {
 	in := &input{
 		op:    opRemoveWatch,
 		path:  filepath.Clean(name),
 		reply: make(chan error),
 	}
 	w.input <- in
 	if err := w.wakeupReader(); err != nil {
 		return err
 	}
 	return <-in.reply
 }
 const (
 	// Options for AddWatch
 	sysFSONESHOT = 0x80000000
 	sysFSONLYDIR = 0x1000000
 	// Events
 	sysFSACCESS     = 0x1
 	sysFSALLEVENTS  = 0xfff
 	sysFSATTRIB     = 0x4
 	sysFSCLOSE      = 0x18
 	sysFSCREATE     = 0x100
 	sysFSDELETE     = 0x200
 	sysFSDELETESELF = 0x400
 	sysFSMODIFY     = 0x2
 	sysFSMOVE       = 0xc0
 	sysFSMOVEDFROM  = 0x40
 	sysFSMOVEDTO    = 0x80
 	sysFSMOVESELF   = 0x800
 	// Special events
 	sysFSIGNORED   = 0x8000
 	sysFSQOVERFLOW = 0x4000
 )
 func newEvent(name string, mask uint32) Event {
 	e := Event{Name: name}
 	if mask&sysFSCREATE == sysFSCREATE || mask&sysFSMOVEDTO == sysFSMOVEDTO {
 		e.Op |= Create
 	}
 	if mask&sysFSDELETE == sysFSDELETE || mask&sysFSDELETESELF == sysFSDELETESELF {
 		e.Op |= Remove
 	}
 	if mask&sysFSMODIFY == sysFSMODIFY {
 		e.Op |= Write
 	}
 	if mask&sysFSMOVE == sysFSMOVE || mask&sysFSMOVESELF == sysFSMOVESELF || mask&sysFSMOVEDFROM == sysFSMOVEDFROM {
 		e.Op |= Rename
 	}
 	if mask&sysFSATTRIB == sysFSATTRIB {
 		e.Op |= Chmod
 	}
 	return e
 }
 const (
 	opAddWatch = iota
 	opRemoveWatch
 )
 const (
 	provisional uint64 = 1 << (32 + iota)
 )
 type input struct {
 	op    int
 	path  string
 	flags uint32
 	reply chan error
 }
 type inode struct {
 	handle syscall.Handle
 	volume uint32
 	index  uint64
 }
 type watch struct {
 	ov     syscall.Overlapped
 	ino    *inode            // i-number
 	path   string            // Directory path
 	mask   uint64            // Directory itself is being watched with these notify flags
 	names  map[string]uint64 // Map of names being watched and their notify flags
 	rename string            // Remembers the old name while renaming a file
 	buf    [4096]byte
 }
 type indexMap map[uint64]*watch
 type watchMap map[uint32]indexMap
 func (w *Watcher) wakeupReader() error {
 	e := syscall.PostQueuedCompletionStatus(w.port, 0, 0, nil)
 	if e != nil {
 		return os.NewSyscallError("PostQueuedCompletionStatus", e)
 	}
 	return nil
 }
 func getDir(pathname string) (dir string, err error) {
 	attr, e := syscall.GetFileAttributes(syscall.StringToUTF16Ptr(pathname))
 	if e != nil {
 		return "", os.NewSyscallError("GetFileAttributes", e)
 	}
 	if attr&syscall.FILE_ATTRIBUTE_DIRECTORY != 0 {
 		dir = pathname
 	} else {
 		dir, _ = filepath.Split(pathname)
 		dir = filepath.Clean(dir)
 	}
 	return
 }
 func getIno(path string) (ino *inode, err error) {
 	h, e := syscall.CreateFile(syscall.StringToUTF16Ptr(path),
 		syscall.FILE_LIST_DIRECTORY,
 		syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE|syscall.FILE_SHARE_DELETE,
 		nil, syscall.OPEN_EXISTING,
 		syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OVERLAPPED, 0)
 	if e != nil {
 		return nil, os.NewSyscallError("CreateFile", e)
 	}
 	var fi syscall.ByHandleFileInformation
 	if e = syscall.GetFileInformationByHandle(h, &fi); e != nil {
 		syscall.CloseHandle(h)
 		return nil, os.NewSyscallError("GetFileInformationByHandle", e)
 	}
 	ino = &inode{
 		handle: h,
 		volume: fi.VolumeSerialNumber,
 		index:  uint64(fi.FileIndexHigh)<<32 | uint64(fi.FileIndexLow),
 	}
 	return ino, nil
 }
 // Must run within the I/O thread.
 func (m watchMap) get(ino *inode) *watch {
 	if i := m[ino.volume]; i != nil {
 		return i[ino.index]
 	}
 	return nil
 }
 // Must run within the I/O thread.
 func (m watchMap) set(ino *inode, watch *watch) {
 	i := m[ino.volume]
 	if i == nil {
 		i = make(indexMap)
 		m[ino.volume] = i
 	}
 	i[ino.index] = watch
 }
 // Must run within the I/O thread.
 func (w *Watcher) addWatch(pathname string, flags uint64) error {
 	dir, err := getDir(pathname)
 	if err != nil {
 		return err
 	}
 	if flags&sysFSONLYDIR != 0 && pathname != dir {
 		return nil
 	}
 	ino, err := getIno(dir)
 	if err != nil {
 		return err
 	}
 	w.mu.Lock()
 	watchEntry := w.watches.get(ino)
 	w.mu.Unlock()
 	if watchEntry == nil {
 		if _, e := syscall.CreateIoCompletionPort(ino.handle, w.port, 0, 0); e != nil {
 			syscall.CloseHandle(ino.handle)
 			return os.NewSyscallError("CreateIoCompletionPort", e)
 		}
 		watchEntry = &watch{
 			ino:   ino,
 			path:  dir,
 			names: make(map[string]uint64),
 		}
 		w.mu.Lock()
 		w.watches.set(ino, watchEntry)
 		w.mu.Unlock()
 		flags |= provisional
 	} else {
 		syscall.CloseHandle(ino.handle)
 	}
 	if pathname == dir {
 		watchEntry.mask |= flags
 	} else {
 		watchEntry.names[filepath.Base(pathname)] |= flags
 	}
 	if err = w.startRead(watchEntry); err != nil {
 		return err
 	}
 	if pathname == dir {
 		watchEntry.mask &= ^provisional
 	} else {
 		watchEntry.names[filepath.Base(pathname)] &= ^provisional
 	}
 	return nil
 }
 // Must run within the I/O thread.
 func (w *Watcher) remWatch(pathname string) error {
 	dir, err := getDir(pathname)
 	if err != nil {
 		return err
 	}
 	ino, err := getIno(dir)
 	if err != nil {
 		return err
 	}
 	w.mu.Lock()
 	watch := w.watches.get(ino)
 	w.mu.Unlock()
 	if watch == nil {
 		return fmt.Errorf("can't remove non-existent watch for: %s", pathname)
 	}
 	if pathname == dir {
 		w.sendEvent(watch.path, watch.mask&sysFSIGNORED)
 		watch.mask = 0
 	} else {
 		name := filepath.Base(pathname)
 		w.sendEvent(filepath.Join(watch.path, name), watch.names[name]&sysFSIGNORED)
 		delete(watch.names, name)
 	}
 	return w.startRead(watch)
 }
 // Must run within the I/O thread.
 func (w *Watcher) deleteWatch(watch *watch) {
 	for name, mask := range watch.names {
 		if mask&provisional == 0 {
 			w.sendEvent(filepath.Join(watch.path, name), mask&sysFSIGNORED)
 		}
 		delete(watch.names, name)
 	}
 	if watch.mask != 0 {
 		if watch.mask&provisional == 0 {
 			w.sendEvent(watch.path, watch.mask&sysFSIGNORED)
 		}
 		watch.mask = 0
 	}
 }
 // Must run within the I/O thread.
 func (w *Watcher) startRead(watch *watch) error {
 	if e := syscall.CancelIo(watch.ino.handle); e != nil {
 		w.Errors <- os.NewSyscallError("CancelIo", e)
 		w.deleteWatch(watch)
 	}
 	mask := toWindowsFlags(watch.mask)
 	for _, m := range watch.names {
 		mask |= toWindowsFlags(m)
 	}
 	if mask == 0 {
 		if e := syscall.CloseHandle(watch.ino.handle); e != nil {
 			w.Errors <- os.NewSyscallError("CloseHandle", e)
 		}
 		w.mu.Lock()
 		delete(w.watches[watch.ino.volume], watch.ino.index)
 		w.mu.Unlock()
 		return nil
 	}
 	e := syscall.ReadDirectoryChanges(watch.ino.handle, &watch.buf[0],
 		uint32(unsafe.Sizeof(watch.buf)), false, mask, nil, &watch.ov, 0)
 	if e != nil {
 		err := os.NewSyscallError("ReadDirectoryChanges", e)
 		if e == syscall.ERROR_ACCESS_DENIED && watch.mask&provisional == 0 {
 			// Watched directory was probably removed
 			if w.sendEvent(watch.path, watch.mask&sysFSDELETESELF) {
 				if watch.mask&sysFSONESHOT != 0 {
 					watch.mask = 0
 				}
 			}
 			err = nil
 		}
 		w.deleteWatch(watch)
 		w.startRead(watch)
 		return err
 	}
 	return nil
 }
 // readEvents reads from the I/O completion port, converts the
 // received events into Event objects and sends them via the Events channel.
 // Entry point to the I/O thread.
 func (w *Watcher) readEvents() {
 	var (
 		n, key uint32
 		ov     *syscall.Overlapped
 	)
 	runtime.LockOSThread()
 	for {
 		e := syscall.GetQueuedCompletionStatus(w.port, &n, &key, &ov, syscall.INFINITE)
 		watch := (*watch)(unsafe.Pointer(ov))
 		if watch == nil {
 			select {
 			case ch := <-w.quit:
 				w.mu.Lock()
 				var indexes []indexMap
 				for _, index := range w.watches {
 					indexes = append(indexes, index)
 				}
 				w.mu.Unlock()
 				for _, index := range indexes {
 					for _, watch := range index {
 						w.deleteWatch(watch)
 						w.startRead(watch)
 					}
 				}
 				var err error
 				if e := syscall.CloseHandle(w.port); e != nil {
 					err = os.NewSyscallError("CloseHandle", e)
 				}
 				close(w.Events)
 				close(w.Errors)
 				ch <- err
 				return
 			case in := <-w.input:
 				switch in.op {
 				case opAddWatch:
 					in.reply <- w.addWatch(in.path, uint64(in.flags))
 				case opRemoveWatch:
 					in.reply <- w.remWatch(in.path)
 				}
 			default:
 			}
 			continue
 		}
 		switch e {
 		case syscall.ERROR_MORE_DATA:
 			if watch == nil {
 				w.Errors <- errors.New("ERROR_MORE_DATA has unexpectedly null lpOverlapped buffer")
 			} else {
 				// The i/o succeeded but the buffer is full.
 				// In theory we should be building up a full packet.
 				// In practice we can get away with just carrying on.
 				n = uint32(unsafe.Sizeof(watch.buf))
 			}
 		case syscall.ERROR_ACCESS_DENIED:
 			// Watched directory was probably removed
 			w.sendEvent(watch.path, watch.mask&sysFSDELETESELF)
 			w.deleteWatch(watch)
 			w.startRead(watch)
 			continue
 		case syscall.ERROR_OPERATION_ABORTED:
 			// CancelIo was called on this handle
 			continue
 		default:
 			w.Errors <- os.NewSyscallError("GetQueuedCompletionPort", e)
 			continue
 		case nil:
 		}
 		var offset uint32
 		for {
 			if n == 0 {
 				w.Events <- newEvent("", sysFSQOVERFLOW)
 				w.Errors <- errors.New("short read in readEvents()")
 				break
 			}
 			// Point "raw" to the event in the buffer
 			raw := (*syscall.FileNotifyInformation)(unsafe.Pointer(&watch.buf[offset]))
 			buf := (*[syscall.MAX_PATH]uint16)(unsafe.Pointer(&raw.FileName))
 			name := syscall.UTF16ToString(buf[:raw.FileNameLength/2])
 			fullname := filepath.Join(watch.path, name)
 			var mask uint64
 			switch raw.Action {
 			case syscall.FILE_ACTION_REMOVED:
 				mask = sysFSDELETESELF
 			case syscall.FILE_ACTION_MODIFIED:
 				mask = sysFSMODIFY
 			case syscall.FILE_ACTION_RENAMED_OLD_NAME:
 				watch.rename = name
 			case syscall.FILE_ACTION_RENAMED_NEW_NAME:
 				if watch.names[watch.rename] != 0 {
 					watch.names[name] |= watch.names[watch.rename]
 					delete(watch.names, watch.rename)
 					mask = sysFSMOVESELF
 				}
 			}
 			sendNameEvent := func() {
 				if w.sendEvent(fullname, watch.names[name]&mask) {
 					if watch.names[name]&sysFSONESHOT != 0 {
 						delete(watch.names, name)
 					}
 				}
 			}
 			if raw.Action != syscall.FILE_ACTION_RENAMED_NEW_NAME {
 				sendNameEvent()
 			}
 			if raw.Action == syscall.FILE_ACTION_REMOVED {
 				w.sendEvent(fullname, watch.names[name]&sysFSIGNORED)
 				delete(watch.names, name)
 			}
 			if w.sendEvent(fullname, watch.mask&toFSnotifyFlags(raw.Action)) {
 				if watch.mask&sysFSONESHOT != 0 {
 					watch.mask = 0
 				}
 			}
 			if raw.Action == syscall.FILE_ACTION_RENAMED_NEW_NAME {
 				fullname = filepath.Join(watch.path, watch.rename)
 				sendNameEvent()
 			}
 			// Move to the next event in the buffer
 			if raw.NextEntryOffset == 0 {
 				break
 			}
 			offset += raw.NextEntryOffset
 			// Error!
 			if offset >= n {
 				w.Errors <- errors.New("Windows system assumed buffer larger than it is, events have likely been missed.")
 				break
 			}
 		}
 		if err := w.startRead(watch); err != nil {
 			w.Errors <- err
 		}
 	}
 }
 func (w *Watcher) sendEvent(name string, mask uint64) bool {
 	if mask == 0 {
 		return false
 	}
 	event := newEvent(name, uint32(mask))
 	select {
 	case ch := <-w.quit:
 		w.quit <- ch
 	case w.Events <- event:
 	}
 	return true
 }
 func toWindowsFlags(mask uint64) uint32 {
 	var m uint32
 	if mask&sysFSACCESS != 0 {
 		m |= syscall.FILE_NOTIFY_CHANGE_LAST_ACCESS
 	}
 	if mask&sysFSMODIFY != 0 {
 		m |= syscall.FILE_NOTIFY_CHANGE_LAST_WRITE
 	}
 	if mask&sysFSATTRIB != 0 {
 		m |= syscall.FILE_NOTIFY_CHANGE_ATTRIBUTES
 	}
 	if mask&(sysFSMOVE|sysFSCREATE|sysFSDELETE) != 0 {
 		m |= syscall.FILE_NOTIFY_CHANGE_FILE_NAME | syscall.FILE_NOTIFY_CHANGE_DIR_NAME
 	}
 	return m
 }
 func toFSnotifyFlags(action uint32) uint64 {
 	switch action {
 	case syscall.FILE_ACTION_ADDED:
 		return sysFSCREATE
 	case syscall.FILE_ACTION_REMOVED:
 		return sysFSDELETE
 	case syscall.FILE_ACTION_MODIFIED:
 		return sysFSMODIFY
 	case syscall.FILE_ACTION_RENAMED_OLD_NAME:
 		return sysFSMOVEDFROM
 	case syscall.FILE_ACTION_RENAMED_NEW_NAME:
 		return sysFSMOVEDTO
 	}
 	return 0
 }
--- a/vendor/github.com/golang/glog/LICENSE
+++ b/vendor/github.com/golang/glog/LICENSE
@@ -0,0 +1,191 @@
 Apache License
 Version 2.0, January 2004
 http://www.apache.org/licenses/
 TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 1. Definitions.
 "License" shall mean the terms and conditions for use, reproduction, and
 distribution as defined by Sections 1 through 9 of this document.
 "Licensor" shall mean the copyright owner or entity authorized by the copyright
 owner that is granting the License.
 "Legal Entity" shall mean the union of the acting entity and all other entities
 that control, are controlled by, or are under common control with that entity.
 For the purposes of this definition, "control" means (i) the power, direct or
 indirect, to cause the direction or management of such entity, whether by
 contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
 outstanding shares, or (iii) beneficial ownership of such entity.
 "You" (or "Your") shall mean an individual or Legal Entity exercising
 permissions granted by this License.
 "Source" form shall mean the preferred form for making modifications, including
 but not limited to software source code, documentation source, and configuration
 files.
 "Object" form shall mean any form resulting from mechanical transformation or
 translation of a Source form, including but not limited to compiled object code,
 generated documentation, and conversions to other media types.
 "Work" shall mean the work of authorship, whether in Source or Object form, made
 available under the License, as indicated by a copyright notice that is included
 in or attached to the work (an example is provided in the Appendix below).
 "Derivative Works" shall mean any work, whether in Source or Object form, that
 is based on (or derived from) the Work and for which the editorial revisions,
 annotations, elaborations, or other modifications represent, as a whole, an
 original work of authorship. For the purposes of this License, Derivative Works
 shall not include works that remain separable from, or merely link (or bind by
 name) to the interfaces of, the Work and Derivative Works thereof.
 "Contribution" shall mean any work of authorship, including the original version
 of the Work and any modifications or additions to that Work or Derivative Works
 thereof, that is intentionally submitted to Licensor for inclusion in the Work
 by the copyright owner or by an individual or Legal Entity authorized to submit
 on behalf of the copyright owner. For the purposes of this definition,
 "submitted" means any form of electronic, verbal, or written communication sent
 to the Licensor or its representatives, including but not limited to
 communication on electronic mailing lists, source code control systems, and
 issue tracking systems that are managed by, or on behalf of, the Licensor for
 the purpose of discussing and improving the Work, but excluding communication
 that is conspicuously marked or otherwise designated in writing by the copyright
 owner as "Not a Contribution."
 "Contributor" shall mean Licensor and any individual or Legal Entity on behalf
 of whom a Contribution has been received by Licensor and subsequently
 incorporated within the Work.
 2. Grant of Copyright License.
 Subject to the terms and conditions of this License, each Contributor hereby
 grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 irrevocable copyright license to reproduce, prepare Derivative Works of,
 publicly display, publicly perform, sublicense, and distribute the Work and such
 Derivative Works in Source or Object form.
 3. Grant of Patent License.
 Subject to the terms and conditions of this License, each Contributor hereby
 grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 irrevocable (except as stated in this section) patent license to make, have
 made, use, offer to sell, sell, import, and otherwise transfer the Work, where
 such license applies only to those patent claims licensable by such Contributor
 that are necessarily infringed by their Contribution(s) alone or by combination
 of their Contribution(s) with the Work to which such Contribution(s) was
 submitted. If You institute patent litigation against any entity (including a
 cross-claim or counterclaim in a lawsuit) alleging that the Work or a
 Contribution incorporated within the Work constitutes direct or contributory
 patent infringement, then any patent licenses granted to You under this License
 for that Work shall terminate as of the date such litigation is filed.
 4. Redistribution.
 You may reproduce and distribute copies of the Work or Derivative Works thereof
 in any medium, with or without modifications, and in Source or Object form,
 provided that You meet the following conditions:
 You must give any other recipients of the Work or Derivative Works a copy of
 this License; and
 You must cause any modified files to carry prominent notices stating that You
 changed the files; and
 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
 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/golang/glog/README
+++ b/vendor/github.com/golang/glog/README
@@ -0,0 +1,44 @@
 glog
 ====
 Leveled execution logs for Go.
 This is an efficient pure Go implementation of leveled logs in the
 manner of the open source C++ package
 	https://github.com/google/glog
 By binding methods to booleans it is possible to use the log package
 without paying the expense of evaluating the arguments to the log.
 Through the -vmodule flag, the package also provides fine-grained
 control over logging at the file level.
 The comment from glog.go introduces the ideas:
 	Package glog implements logging analogous to the Google-internal
 	C++ INFO/ERROR/V setup.  It provides functions Info, Warning,
 	Error, Fatal, plus formatting variants such as Infof. It
 	also provides V-style logging controlled by the -v and
 	-vmodule=file=2 flags.
 	Basic examples:
 		glog.Info("Prepare to repel boarders")
 		glog.Fatalf("Initialization failed: %s", err)
 	See the documentation for the V function for an explanation
 	of these examples:
 		if glog.V(2) {
 			glog.Info("Starting transaction...")
 		}
 		glog.V(2).Infoln("Processed", nItems, "elements")
 The repository contains an open source version of the log package
 used inside Google. The master copy of the source lives inside
 Google, not here. The code in this repo is for export only and is not itself
 under development. Feature requests will be ignored.
 Send bug reports to golang-nuts@googlegroups.com.
--- a/vendor/github.com/golang/glog/glog.go
+++ b/vendor/github.com/golang/glog/glog.go
--- a/vendor/github.com/golang/glog/glog_file.go
+++ b/vendor/github.com/golang/glog/glog_file.go
@@ -0,0 +1,124 @@
 // Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
 //
 // Copyright 2013 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // File I/O for logs.
 package glog
 import (
 	"errors"
 	"flag"
 	"fmt"
 	"os"
 	"os/user"
 	"path/filepath"
 	"strings"
 	"sync"
 	"time"
 )
 // MaxSize is the maximum size of a log file in bytes.
 var MaxSize uint64 = 1024 * 1024 * 1800
 // logDirs lists the candidate directories for new log files.
 var logDirs []string
 // If non-empty, overrides the choice of directory in which to write logs.
 // See createLogDirs for the full list of possible destinations.
 var logDir = flag.String("log_dir", "", "If non-empty, write log files in this directory")
 func createLogDirs() {
 	if *logDir != "" {
 		logDirs = append(logDirs, *logDir)
 	}
 	logDirs = append(logDirs, os.TempDir())
 }
 var (
 	pid      = os.Getpid()
 	program  = filepath.Base(os.Args[0])
 	host     = "unknownhost"
 	userName = "unknownuser"
 )
 func init() {
 	h, err := os.Hostname()
 	if err == nil {
 		host = shortHostname(h)
 	}
 	current, err := user.Current()
 	if err == nil {
 		userName = current.Username
 	}
 	// Sanitize userName since it may contain filepath separators on Windows.
 	userName = strings.Replace(userName, `\`, "_", -1)
 }
 // shortHostname returns its argument, truncating at the first period.
 // For instance, given "www.google.com" it returns "www".
 func shortHostname(hostname string) string {
 	if i := strings.Index(hostname, "."); i >= 0 {
 		return hostname[:i]
 	}
 	return hostname
 }
 // logName returns a new log file name containing tag, with start time t, and
 // the name for the symlink for tag.
 func logName(tag string, t time.Time) (name, link string) {
 	name = fmt.Sprintf("%s.%s.%s.log.%s.%04d%02d%02d-%02d%02d%02d.%d",
 		program,
 		host,
 		userName,
 		tag,
 		t.Year(),
 		t.Month(),
 		t.Day(),
 		t.Hour(),
 		t.Minute(),
 		t.Second(),
 		pid)
 	return name, program + "." + tag
 }
 var onceLogDirs sync.Once
 // create creates a new log file and returns the file and its filename, which
 // contains tag ("INFO", "FATAL", etc.) and t.  If the file is created
 // successfully, create also attempts to update the symlink for that tag, ignoring
 // errors.
 func create(tag string, t time.Time) (f *os.File, filename string, err error) {
 	onceLogDirs.Do(createLogDirs)
 	if len(logDirs) == 0 {
 		return nil, "", errors.New("log: no log dirs")
 	}
 	name, link := logName(tag, t)
 	var lastErr error
 	for _, dir := range logDirs {
 		fname := filepath.Join(dir, name)
 		f, err := os.Create(fname)
 		if err == nil {
 			symlink := filepath.Join(dir, link)
 			os.Remove(symlink)        // ignore err
 			os.Symlink(name, symlink) // ignore err
 			return f, fname, nil
 		}
 		lastErr = err
 	}
 	return nil, "", fmt.Errorf("log: cannot create log: %v", lastErr)
 }
--- a/vendor/github.com/golang/protobuf/AUTHORS
+++ b/vendor/github.com/golang/protobuf/AUTHORS
@@ -0,0 +1,3 @@
 # This source code refers to The Go Authors for copyright purposes.
 # The master list of authors is in the main Go distribution,
 # visible at http://tip.golang.org/AUTHORS.
--- a/vendor/github.com/golang/protobuf/CONTRIBUTORS
+++ b/vendor/github.com/golang/protobuf/CONTRIBUTORS
@@ -0,0 +1,3 @@
 # This source code was written by the Go contributors.
 # The master list of contributors is in the main Go distribution,
 # visible at http://tip.golang.org/CONTRIBUTORS.
--- a/vendor/github.com/golang/protobuf/LICENSE
+++ b/vendor/github.com/golang/protobuf/LICENSE
@@ -0,0 +1,28 @@
 Copyright 2010 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/golang/protobuf/proto/clone.go
+++ b/vendor/github.com/golang/protobuf/proto/clone.go
@@ -0,0 +1,253 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2011 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // 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.
 // Protocol buffer deep copy and merge.
 // TODO: RawMessage.
 package proto
 import (
 	"fmt"
 	"log"
 	"reflect"
 	"strings"
 )
 // Clone returns a deep copy of a protocol buffer.
 func Clone(src Message) Message {
 	in := reflect.ValueOf(src)
 	if in.IsNil() {
 		return src
 	}
 	out := reflect.New(in.Type().Elem())
 	dst := out.Interface().(Message)
 	Merge(dst, src)
 	return dst
 }
 // Merger is the interface representing objects that can merge messages of the same type.
 type Merger interface {
 	// Merge merges src into this message.
 	// Required and optional fields that are set in src will be set to that value in dst.
 	// Elements of repeated fields will be appended.
 	//
 	// Merge may panic if called with a different argument type than the receiver.
 	Merge(src Message)
 }
 // generatedMerger is the custom merge method that generated protos will have.
 // We must add this method since a generate Merge method will conflict with
 // many existing protos that have a Merge data field already defined.
 type generatedMerger interface {
 	XXX_Merge(src Message)
 }
 // Merge merges src into dst.
 // Required and optional fields that are set in src will be set to that value in dst.
 // Elements of repeated fields will be appended.
 // Merge panics if src and dst are not the same type, or if dst is nil.
 func Merge(dst, src Message) {
 	if m, ok := dst.(Merger); ok {
 		m.Merge(src)
 		return
 	}
 	in := reflect.ValueOf(src)
 	out := reflect.ValueOf(dst)
 	if out.IsNil() {
 		panic("proto: nil destination")
 	}
 	if in.Type() != out.Type() {
 		panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src))
 	}
 	if in.IsNil() {
 		return // Merge from nil src is a noop
 	}
 	if m, ok := dst.(generatedMerger); ok {
 		m.XXX_Merge(src)
 		return
 	}
 	mergeStruct(out.Elem(), in.Elem())
 }
 func mergeStruct(out, in reflect.Value) {
 	sprop := GetProperties(in.Type())
 	for i := 0; i < in.NumField(); i++ {
 		f := in.Type().Field(i)
 		if strings.HasPrefix(f.Name, "XXX_") {
 			continue
 		}
 		mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
 	}
 	if emIn, err := extendable(in.Addr().Interface()); err == nil {
 		emOut, _ := extendable(out.Addr().Interface())
 		mIn, muIn := emIn.extensionsRead()
 		if mIn != nil {
 			mOut := emOut.extensionsWrite()
 			muIn.Lock()
 			mergeExtension(mOut, mIn)
 			muIn.Unlock()
 		}
 	}
 	uf := in.FieldByName("XXX_unrecognized")
 	if !uf.IsValid() {
 		return
 	}
 	uin := uf.Bytes()
 	if len(uin) > 0 {
 		out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
 	}
 }
 // mergeAny performs a merge between two values of the same type.
 // viaPtr indicates whether the values were indirected through a pointer (implying proto2).
 // prop is set if this is a struct field (it may be nil).
 func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
 	if in.Type() == protoMessageType {
 		if !in.IsNil() {
 			if out.IsNil() {
 				out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
 			} else {
 				Merge(out.Interface().(Message), in.Interface().(Message))
 			}
 		}
 		return
 	}
 	switch in.Kind() {
 	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
 		reflect.String, reflect.Uint32, reflect.Uint64:
 		if !viaPtr && isProto3Zero(in) {
 			return
 		}
 		out.Set(in)
 	case reflect.Interface:
 		// Probably a oneof field; copy non-nil values.
 		if in.IsNil() {
 			return
 		}
 		// Allocate destination if it is not set, or set to a different type.
 		// Otherwise we will merge as normal.
 		if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
 			out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
 		}
 		mergeAny(out.Elem(), in.Elem(), false, nil)
 	case reflect.Map:
 		if in.Len() == 0 {
 			return
 		}
 		if out.IsNil() {
 			out.Set(reflect.MakeMap(in.Type()))
 		}
 		// For maps with value types of *T or []byte we need to deep copy each value.
 		elemKind := in.Type().Elem().Kind()
 		for _, key := range in.MapKeys() {
 			var val reflect.Value
 			switch elemKind {
 			case reflect.Ptr:
 				val = reflect.New(in.Type().Elem().Elem())
 				mergeAny(val, in.MapIndex(key), false, nil)
 			case reflect.Slice:
 				val = in.MapIndex(key)
 				val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
 			default:
 				val = in.MapIndex(key)
 			}
 			out.SetMapIndex(key, val)
 		}
 	case reflect.Ptr:
 		if in.IsNil() {
 			return
 		}
 		if out.IsNil() {
 			out.Set(reflect.New(in.Elem().Type()))
 		}
 		mergeAny(out.Elem(), in.Elem(), true, nil)
 	case reflect.Slice:
 		if in.IsNil() {
 			return
 		}
 		if in.Type().Elem().Kind() == reflect.Uint8 {
 			// []byte is a scalar bytes field, not a repeated field.
 			// Edge case: if this is in a proto3 message, a zero length
 			// bytes field is considered the zero value, and should not
 			// be merged.
 			if prop != nil && prop.proto3 && in.Len() == 0 {
 				return
 			}
 			// Make a deep copy.
 			// Append to []byte{} instead of []byte(nil) so that we never end up
 			// with a nil result.
 			out.SetBytes(append([]byte{}, in.Bytes()...))
 			return
 		}
 		n := in.Len()
 		if out.IsNil() {
 			out.Set(reflect.MakeSlice(in.Type(), 0, n))
 		}
 		switch in.Type().Elem().Kind() {
 		case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
 			reflect.String, reflect.Uint32, reflect.Uint64:
 			out.Set(reflect.AppendSlice(out, in))
 		default:
 			for i := 0; i < n; i++ {
 				x := reflect.Indirect(reflect.New(in.Type().Elem()))
 				mergeAny(x, in.Index(i), false, nil)
 				out.Set(reflect.Append(out, x))
 			}
 		}
 	case reflect.Struct:
 		mergeStruct(out, in)
 	default:
 		// unknown type, so not a protocol buffer
 		log.Printf("proto: don't know how to copy %v", in)
 	}
 }
 func mergeExtension(out, in map[int32]Extension) {
 	for extNum, eIn := range in {
 		eOut := Extension{desc: eIn.desc}
 		if eIn.value != nil {
 			v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
 			mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
 			eOut.value = v.Interface()
 		}
 		if eIn.enc != nil {
 			eOut.enc = make([]byte, len(eIn.enc))
 			copy(eOut.enc, eIn.enc)
 		}
 		out[extNum] = eOut
 	}
 }
--- a/vendor/github.com/golang/protobuf/proto/decode.go
+++ b/vendor/github.com/golang/protobuf/proto/decode.go
@@ -0,0 +1,427 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2010 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 /*
 * Routines for decoding protocol buffer data to construct in-memory representations.
 */
 import (
 	"errors"
 	"fmt"
 	"io"
 )
 // errOverflow is returned when an integer is too large to be represented.
 var errOverflow = errors.New("proto: integer overflow")
 // ErrInternalBadWireType is returned by generated code when an incorrect
 // wire type is encountered. It does not get returned to user code.
 var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
 // DecodeVarint reads a varint-encoded integer from the slice.
 // It returns the integer and the number of bytes consumed, or
 // zero if there is not enough.
 // This is the format for the
 // int32, int64, uint32, uint64, bool, and enum
 // protocol buffer types.
 func DecodeVarint(buf []byte) (x uint64, n int) {
 	for shift := uint(0); shift < 64; shift += 7 {
 		if n >= len(buf) {
 			return 0, 0
 		}
 		b := uint64(buf[n])
 		n++
 		x |= (b & 0x7F) << shift
 		if (b & 0x80) == 0 {
 			return x, n
 		}
 	}
 	// The number is too large to represent in a 64-bit value.
 	return 0, 0
 }
 func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
 	i := p.index
 	l := len(p.buf)
 	for shift := uint(0); shift < 64; shift += 7 {
 		if i >= l {
 			err = io.ErrUnexpectedEOF
 			return
 		}
 		b := p.buf[i]
 		i++
 		x |= (uint64(b) & 0x7F) << shift
 		if b < 0x80 {
 			p.index = i
 			return
 		}
 	}
 	// The number is too large to represent in a 64-bit value.
 	err = errOverflow
 	return
 }
 // DecodeVarint reads a varint-encoded integer from the Buffer.
 // This is the format for the
 // int32, int64, uint32, uint64, bool, and enum
 // protocol buffer types.
 func (p *Buffer) DecodeVarint() (x uint64, err error) {
 	i := p.index
 	buf := p.buf
 	if i >= len(buf) {
 		return 0, io.ErrUnexpectedEOF
 	} else if buf[i] < 0x80 {
 		p.index++
 		return uint64(buf[i]), nil
 	} else if len(buf)-i < 10 {
 		return p.decodeVarintSlow()
 	}
 	var b uint64
 	// we already checked the first byte
 	x = uint64(buf[i]) - 0x80
 	i++
 	b = uint64(buf[i])
 	i++
 	x += b << 7
 	if b&0x80 == 0 {
 		goto done
 	}
 	x -= 0x80 << 7
 	b = uint64(buf[i])
 	i++
 	x += b << 14
 	if b&0x80 == 0 {
 		goto done
 	}
 	x -= 0x80 << 14
 	b = uint64(buf[i])
 	i++
 	x += b << 21
 	if b&0x80 == 0 {
 		goto done
 	}
 	x -= 0x80 << 21
 	b = uint64(buf[i])
 	i++
 	x += b << 28
 	if b&0x80 == 0 {
 		goto done
 	}
 	x -= 0x80 << 28
 	b = uint64(buf[i])
 	i++
 	x += b << 35
 	if b&0x80 == 0 {
 		goto done
 	}
 	x -= 0x80 << 35
 	b = uint64(buf[i])
 	i++
 	x += b << 42
 	if b&0x80 == 0 {
 		goto done
 	}
 	x -= 0x80 << 42
 	b = uint64(buf[i])
 	i++
 	x += b << 49
 	if b&0x80 == 0 {
 		goto done
 	}
 	x -= 0x80 << 49
 	b = uint64(buf[i])
 	i++
 	x += b << 56
 	if b&0x80 == 0 {
 		goto done
 	}
 	x -= 0x80 << 56
 	b = uint64(buf[i])
 	i++
 	x += b << 63
 	if b&0x80 == 0 {
 		goto done
 	}
 	return 0, errOverflow
 done:
 	p.index = i
 	return x, nil
 }
 // DecodeFixed64 reads a 64-bit integer from the Buffer.
 // This is the format for the
 // fixed64, sfixed64, and double protocol buffer types.
 func (p *Buffer) DecodeFixed64() (x uint64, err error) {
 	// x, err already 0
 	i := p.index + 8
 	if i < 0 || i > len(p.buf) {
 		err = io.ErrUnexpectedEOF
 		return
 	}
 	p.index = i
 	x = uint64(p.buf[i-8])
 	x |= uint64(p.buf[i-7]) << 8
 	x |= uint64(p.buf[i-6]) << 16
 	x |= uint64(p.buf[i-5]) << 24
 	x |= uint64(p.buf[i-4]) << 32
 	x |= uint64(p.buf[i-3]) << 40
 	x |= uint64(p.buf[i-2]) << 48
 	x |= uint64(p.buf[i-1]) << 56
 	return
 }
 // DecodeFixed32 reads a 32-bit integer from the Buffer.
 // This is the format for the
 // fixed32, sfixed32, and float protocol buffer types.
 func (p *Buffer) DecodeFixed32() (x uint64, err error) {
 	// x, err already 0
 	i := p.index + 4
 	if i < 0 || i > len(p.buf) {
 		err = io.ErrUnexpectedEOF
 		return
 	}
 	p.index = i
 	x = uint64(p.buf[i-4])
 	x |= uint64(p.buf[i-3]) << 8
 	x |= uint64(p.buf[i-2]) << 16
 	x |= uint64(p.buf[i-1]) << 24
 	return
 }
 // DecodeZigzag64 reads a zigzag-encoded 64-bit integer
 // from the Buffer.
 // This is the format used for the sint64 protocol buffer type.
 func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
 	x, err = p.DecodeVarint()
 	if err != nil {
 		return
 	}
 	x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
 	return
 }
 // DecodeZigzag32 reads a zigzag-encoded 32-bit integer
 // from  the Buffer.
 // This is the format used for the sint32 protocol buffer type.
 func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
 	x, err = p.DecodeVarint()
 	if err != nil {
 		return
 	}
 	x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
 	return
 }
 // DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
 // This is the format used for the bytes protocol buffer
 // type and for embedded messages.
 func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
 	n, err := p.DecodeVarint()
 	if err != nil {
 		return nil, err
 	}
 	nb := int(n)
 	if nb < 0 {
 		return nil, fmt.Errorf("proto: bad byte length %d", nb)
 	}
 	end := p.index + nb
 	if end < p.index || end > len(p.buf) {
 		return nil, io.ErrUnexpectedEOF
 	}
 	if !alloc {
 		// todo: check if can get more uses of alloc=false
 		buf = p.buf[p.index:end]
 		p.index += nb
 		return
 	}
 	buf = make([]byte, nb)
 	copy(buf, p.buf[p.index:])
 	p.index += nb
 	return
 }
 // DecodeStringBytes reads an encoded string from the Buffer.
 // This is the format used for the proto2 string type.
 func (p *Buffer) DecodeStringBytes() (s string, err error) {
 	buf, err := p.DecodeRawBytes(false)
 	if err != nil {
 		return
 	}
 	return string(buf), nil
 }
 // Unmarshaler is the interface representing objects that can
 // unmarshal themselves.  The argument points to data that may be
 // overwritten, so implementations should not keep references to the
 // buffer.
 // Unmarshal implementations should not clear the receiver.
 // Any unmarshaled data should be merged into the receiver.
 // Callers of Unmarshal that do not want to retain existing data
 // should Reset the receiver before calling Unmarshal.
 type Unmarshaler interface {
 	Unmarshal([]byte) error
 }
 // newUnmarshaler is the interface representing objects that can
 // unmarshal themselves. The semantics are identical to Unmarshaler.
 //
 // This exists to support protoc-gen-go generated messages.
 // The proto package will stop type-asserting to this interface in the future.
 //
 // DO NOT DEPEND ON THIS.
 type newUnmarshaler interface {
 	XXX_Unmarshal([]byte) error
 }
 // Unmarshal parses the protocol buffer representation in buf and places the
 // decoded result in pb.  If the struct underlying pb does not match
 // the data in buf, the results can be unpredictable.
 //
 // Unmarshal resets pb before starting to unmarshal, so any
 // existing data in pb is always removed. Use UnmarshalMerge
 // to preserve and append to existing data.
 func Unmarshal(buf []byte, pb Message) error {
 	pb.Reset()
 	if u, ok := pb.(newUnmarshaler); ok {
 		return u.XXX_Unmarshal(buf)
 	}
 	if u, ok := pb.(Unmarshaler); ok {
 		return u.Unmarshal(buf)
 	}
 	return NewBuffer(buf).Unmarshal(pb)
 }
 // UnmarshalMerge parses the protocol buffer representation in buf and
 // writes the decoded result to pb.  If the struct underlying pb does not match
 // the data in buf, the results can be unpredictable.
 //
 // UnmarshalMerge merges into existing data in pb.
 // Most code should use Unmarshal instead.
 func UnmarshalMerge(buf []byte, pb Message) error {
 	if u, ok := pb.(newUnmarshaler); ok {
 		return u.XXX_Unmarshal(buf)
 	}
 	if u, ok := pb.(Unmarshaler); ok {
 		// NOTE: The history of proto have unfortunately been inconsistent
 		// whether Unmarshaler should or should not implicitly clear itself.
 		// Some implementations do, most do not.
 		// Thus, calling this here may or may not do what people want.
 		//
 		// See https://github.com/golang/protobuf/issues/424
 		return u.Unmarshal(buf)
 	}
 	return NewBuffer(buf).Unmarshal(pb)
 }
 // DecodeMessage reads a count-delimited message from the Buffer.
 func (p *Buffer) DecodeMessage(pb Message) error {
 	enc, err := p.DecodeRawBytes(false)
 	if err != nil {
 		return err
 	}
 	return NewBuffer(enc).Unmarshal(pb)
 }
 // DecodeGroup reads a tag-delimited group from the Buffer.
 // StartGroup tag is already consumed. This function consumes
 // EndGroup tag.
 func (p *Buffer) DecodeGroup(pb Message) error {
 	b := p.buf[p.index:]
 	x, y := findEndGroup(b)
 	if x < 0 {
 		return io.ErrUnexpectedEOF
 	}
 	err := Unmarshal(b[:x], pb)
 	p.index += y
 	return err
 }
 // Unmarshal parses the protocol buffer representation in the
 // Buffer and places the decoded result in pb.  If the struct
 // underlying pb does not match the data in the buffer, the results can be
 // unpredictable.
 //
 // Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
 func (p *Buffer) Unmarshal(pb Message) error {
 	// If the object can unmarshal itself, let it.
 	if u, ok := pb.(newUnmarshaler); ok {
 		err := u.XXX_Unmarshal(p.buf[p.index:])
 		p.index = len(p.buf)
 		return err
 	}
 	if u, ok := pb.(Unmarshaler); ok {
 		// NOTE: The history of proto have unfortunately been inconsistent
 		// whether Unmarshaler should or should not implicitly clear itself.
 		// Some implementations do, most do not.
 		// Thus, calling this here may or may not do what people want.
 		//
 		// See https://github.com/golang/protobuf/issues/424
 		err := u.Unmarshal(p.buf[p.index:])
 		p.index = len(p.buf)
 		return err
 	}
 	// Slow workaround for messages that aren't Unmarshalers.
 	// This includes some hand-coded .pb.go files and
 	// bootstrap protos.
 	// TODO: fix all of those and then add Unmarshal to
 	// the Message interface. Then:
 	// The cast above and code below can be deleted.
 	// The old unmarshaler can be deleted.
 	// Clients can call Unmarshal directly (can already do that, actually).
 	var info InternalMessageInfo
 	err := info.Unmarshal(pb, p.buf[p.index:])
 	p.index = len(p.buf)
 	return err
 }
--- a/vendor/github.com/golang/protobuf/proto/deprecated.go
+++ b/vendor/github.com/golang/protobuf/proto/deprecated.go
@@ -0,0 +1,38 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2018 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 // Deprecated: do not use.
 type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
 // Deprecated: do not use.
 func GetStats() Stats { return Stats{} }
--- a/vendor/github.com/golang/protobuf/proto/discard.go
+++ b/vendor/github.com/golang/protobuf/proto/discard.go
@@ -0,0 +1,350 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2017 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 import (
 	"fmt"
 	"reflect"
 	"strings"
 	"sync"
 	"sync/atomic"
 )
 type generatedDiscarder interface {
 	XXX_DiscardUnknown()
 }
 // DiscardUnknown recursively discards all unknown fields from this message
 // and all embedded messages.
 //
 // When unmarshaling a message with unrecognized fields, the tags and values
 // of such fields are preserved in the Message. This allows a later call to
 // marshal to be able to produce a message that continues to have those
 // unrecognized fields. To avoid this, DiscardUnknown is used to
 // explicitly clear the unknown fields after unmarshaling.
 //
 // For proto2 messages, the unknown fields of message extensions are only
 // discarded from messages that have been accessed via GetExtension.
 func DiscardUnknown(m Message) {
 	if m, ok := m.(generatedDiscarder); ok {
 		m.XXX_DiscardUnknown()
 		return
 	}
 	// TODO: Dynamically populate a InternalMessageInfo for legacy messages,
 	// but the master branch has no implementation for InternalMessageInfo,
 	// so it would be more work to replicate that approach.
 	discardLegacy(m)
 }
 // DiscardUnknown recursively discards all unknown fields.
 func (a *InternalMessageInfo) DiscardUnknown(m Message) {
 	di := atomicLoadDiscardInfo(&a.discard)
 	if di == nil {
 		di = getDiscardInfo(reflect.TypeOf(m).Elem())
 		atomicStoreDiscardInfo(&a.discard, di)
 	}
 	di.discard(toPointer(&m))
 }
 type discardInfo struct {
 	typ reflect.Type
 	initialized int32 // 0: only typ is valid, 1: everything is valid
 	lock        sync.Mutex
 	fields       []discardFieldInfo
 	unrecognized field
 }
 type discardFieldInfo struct {
 	field   field // Offset of field, guaranteed to be valid
 	discard func(src pointer)
 }
 var (
 	discardInfoMap  = map[reflect.Type]*discardInfo{}
 	discardInfoLock sync.Mutex
 )
 func getDiscardInfo(t reflect.Type) *discardInfo {
 	discardInfoLock.Lock()
 	defer discardInfoLock.Unlock()
 	di := discardInfoMap[t]
 	if di == nil {
 		di = &discardInfo{typ: t}
 		discardInfoMap[t] = di
 	}
 	return di
 }
 func (di *discardInfo) discard(src pointer) {
 	if src.isNil() {
 		return // Nothing to do.
 	}
 	if atomic.LoadInt32(&di.initialized) == 0 {
 		di.computeDiscardInfo()
 	}
 	for _, fi := range di.fields {
 		sfp := src.offset(fi.field)
 		fi.discard(sfp)
 	}
 	// For proto2 messages, only discard unknown fields in message extensions
 	// that have been accessed via GetExtension.
 	if em, err := extendable(src.asPointerTo(di.typ).Interface()); err == nil {
 		// Ignore lock since DiscardUnknown is not concurrency safe.
 		emm, _ := em.extensionsRead()
 		for _, mx := range emm {
 			if m, ok := mx.value.(Message); ok {
 				DiscardUnknown(m)
 			}
 		}
 	}
 	if di.unrecognized.IsValid() {
 		*src.offset(di.unrecognized).toBytes() = nil
 	}
 }
 func (di *discardInfo) computeDiscardInfo() {
 	di.lock.Lock()
 	defer di.lock.Unlock()
 	if di.initialized != 0 {
 		return
 	}
 	t := di.typ
 	n := t.NumField()
 	for i := 0; i < n; i++ {
 		f := t.Field(i)
 		if strings.HasPrefix(f.Name, "XXX_") {
 			continue
 		}
 		dfi := discardFieldInfo{field: toField(&f)}
 		tf := f.Type
 		// Unwrap tf to get its most basic type.
 		var isPointer, isSlice bool
 		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
 			isSlice = true
 			tf = tf.Elem()
 		}
 		if tf.Kind() == reflect.Ptr {
 			isPointer = true
 			tf = tf.Elem()
 		}
 		if isPointer && isSlice && tf.Kind() != reflect.Struct {
 			panic(fmt.Sprintf("%v.%s cannot be a slice of pointers to primitive types", t, f.Name))
 		}
 		switch tf.Kind() {
 		case reflect.Struct:
 			switch {
 			case !isPointer:
 				panic(fmt.Sprintf("%v.%s cannot be a direct struct value", t, f.Name))
 			case isSlice: // E.g., []*pb.T
 				di := getDiscardInfo(tf)
 				dfi.discard = func(src pointer) {
 					sps := src.getPointerSlice()
 					for _, sp := range sps {
 						if !sp.isNil() {
 							di.discard(sp)
 						}
 					}
 				}
 			default: // E.g., *pb.T
 				di := getDiscardInfo(tf)
 				dfi.discard = func(src pointer) {
 					sp := src.getPointer()
 					if !sp.isNil() {
 						di.discard(sp)
 					}
 				}
 			}
 		case reflect.Map:
 			switch {
 			case isPointer || isSlice:
 				panic(fmt.Sprintf("%v.%s cannot be a pointer to a map or a slice of map values", t, f.Name))
 			default: // E.g., map[K]V
 				if tf.Elem().Kind() == reflect.Ptr { // Proto struct (e.g., *T)
 					dfi.discard = func(src pointer) {
 						sm := src.asPointerTo(tf).Elem()
 						if sm.Len() == 0 {
 							return
 						}
 						for _, key := range sm.MapKeys() {
 							val := sm.MapIndex(key)
 							DiscardUnknown(val.Interface().(Message))
 						}
 					}
 				} else {
 					dfi.discard = func(pointer) {} // Noop
 				}
 			}
 		case reflect.Interface:
 			// Must be oneof field.
 			switch {
 			case isPointer || isSlice:
 				panic(fmt.Sprintf("%v.%s cannot be a pointer to a interface or a slice of interface values", t, f.Name))
 			default: // E.g., interface{}
 				// TODO: Make this faster?
 				dfi.discard = func(src pointer) {
 					su := src.asPointerTo(tf).Elem()
 					if !su.IsNil() {
 						sv := su.Elem().Elem().Field(0)
 						if sv.Kind() == reflect.Ptr && sv.IsNil() {
 							return
 						}
 						switch sv.Type().Kind() {
 						case reflect.Ptr: // Proto struct (e.g., *T)
 							DiscardUnknown(sv.Interface().(Message))
 						}
 					}
 				}
 			}
 		default:
 			continue
 		}
 		di.fields = append(di.fields, dfi)
 	}
 	di.unrecognized = invalidField
 	if f, ok := t.FieldByName("XXX_unrecognized"); ok {
 		if f.Type != reflect.TypeOf([]byte{}) {
 			panic("expected XXX_unrecognized to be of type []byte")
 		}
 		di.unrecognized = toField(&f)
 	}
 	atomic.StoreInt32(&di.initialized, 1)
 }
 func discardLegacy(m Message) {
 	v := reflect.ValueOf(m)
 	if v.Kind() != reflect.Ptr || v.IsNil() {
 		return
 	}
 	v = v.Elem()
 	if v.Kind() != reflect.Struct {
 		return
 	}
 	t := v.Type()
 	for i := 0; i < v.NumField(); i++ {
 		f := t.Field(i)
 		if strings.HasPrefix(f.Name, "XXX_") {
 			continue
 		}
 		vf := v.Field(i)
 		tf := f.Type
 		// Unwrap tf to get its most basic type.
 		var isPointer, isSlice bool
 		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
 			isSlice = true
 			tf = tf.Elem()
 		}
 		if tf.Kind() == reflect.Ptr {
 			isPointer = true
 			tf = tf.Elem()
 		}
 		if isPointer && isSlice && tf.Kind() != reflect.Struct {
 			panic(fmt.Sprintf("%T.%s cannot be a slice of pointers to primitive types", m, f.Name))
 		}
 		switch tf.Kind() {
 		case reflect.Struct:
 			switch {
 			case !isPointer:
 				panic(fmt.Sprintf("%T.%s cannot be a direct struct value", m, f.Name))
 			case isSlice: // E.g., []*pb.T
 				for j := 0; j < vf.Len(); j++ {
 					discardLegacy(vf.Index(j).Interface().(Message))
 				}
 			default: // E.g., *pb.T
 				discardLegacy(vf.Interface().(Message))
 			}
 		case reflect.Map:
 			switch {
 			case isPointer || isSlice:
 				panic(fmt.Sprintf("%T.%s cannot be a pointer to a map or a slice of map values", m, f.Name))
 			default: // E.g., map[K]V
 				tv := vf.Type().Elem()
 				if tv.Kind() == reflect.Ptr && tv.Implements(protoMessageType) { // Proto struct (e.g., *T)
 					for _, key := range vf.MapKeys() {
 						val := vf.MapIndex(key)
 						discardLegacy(val.Interface().(Message))
 					}
 				}
 			}
 		case reflect.Interface:
 			// Must be oneof field.
 			switch {
 			case isPointer || isSlice:
 				panic(fmt.Sprintf("%T.%s cannot be a pointer to a interface or a slice of interface values", m, f.Name))
 			default: // E.g., test_proto.isCommunique_Union interface
 				if !vf.IsNil() && f.Tag.Get("protobuf_oneof") != "" {
 					vf = vf.Elem() // E.g., *test_proto.Communique_Msg
 					if !vf.IsNil() {
 						vf = vf.Elem()   // E.g., test_proto.Communique_Msg
 						vf = vf.Field(0) // E.g., Proto struct (e.g., *T) or primitive value
 						if vf.Kind() == reflect.Ptr {
 							discardLegacy(vf.Interface().(Message))
 						}
 					}
 				}
 			}
 		}
 	}
 	if vf := v.FieldByName("XXX_unrecognized"); vf.IsValid() {
 		if vf.Type() != reflect.TypeOf([]byte{}) {
 			panic("expected XXX_unrecognized to be of type []byte")
 		}
 		vf.Set(reflect.ValueOf([]byte(nil)))
 	}
 	// For proto2 messages, only discard unknown fields in message extensions
 	// that have been accessed via GetExtension.
 	if em, err := extendable(m); err == nil {
 		// Ignore lock since discardLegacy is not concurrency safe.
 		emm, _ := em.extensionsRead()
 		for _, mx := range emm {
 			if m, ok := mx.value.(Message); ok {
 				discardLegacy(m)
 			}
 		}
 	}
 }
--- a/vendor/github.com/golang/protobuf/proto/encode.go
+++ b/vendor/github.com/golang/protobuf/proto/encode.go
@@ -0,0 +1,203 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2010 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 /*
 * Routines for encoding data into the wire format for protocol buffers.
 */
 import (
 	"errors"
 	"reflect"
 )
 var (
 	// errRepeatedHasNil is the error returned if Marshal is called with
 	// a struct with a repeated field containing a nil element.
 	errRepeatedHasNil = errors.New("proto: repeated field has nil element")
 	// errOneofHasNil is the error returned if Marshal is called with
 	// a struct with a oneof field containing a nil element.
 	errOneofHasNil = errors.New("proto: oneof field has nil value")
 	// ErrNil is the error returned if Marshal is called with nil.
 	ErrNil = errors.New("proto: Marshal called with nil")
 	// ErrTooLarge is the error returned if Marshal is called with a
 	// message that encodes to >2GB.
 	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
 )
 // The fundamental encoders that put bytes on the wire.
 // Those that take integer types all accept uint64 and are
 // therefore of type valueEncoder.
 const maxVarintBytes = 10 // maximum length of a varint
 // EncodeVarint returns the varint encoding of x.
 // This is the format for the
 // int32, int64, uint32, uint64, bool, and enum
 // protocol buffer types.
 // Not used by the package itself, but helpful to clients
 // wishing to use the same encoding.
 func EncodeVarint(x uint64) []byte {
 	var buf [maxVarintBytes]byte
 	var n int
 	for n = 0; x > 127; n++ {
 		buf[n] = 0x80 | uint8(x&0x7F)
 		x >>= 7
 	}
 	buf[n] = uint8(x)
 	n++
 	return buf[0:n]
 }
 // EncodeVarint writes a varint-encoded integer to the Buffer.
 // This is the format for the
 // int32, int64, uint32, uint64, bool, and enum
 // protocol buffer types.
 func (p *Buffer) EncodeVarint(x uint64) error {
 	for x >= 1<<7 {
 		p.buf = append(p.buf, uint8(x&0x7f|0x80))
 		x >>= 7
 	}
 	p.buf = append(p.buf, uint8(x))
 	return nil
 }
 // SizeVarint returns the varint encoding size of an integer.
 func SizeVarint(x uint64) int {
 	switch {
 	case x < 1<<7:
 		return 1
 	case x < 1<<14:
 		return 2
 	case x < 1<<21:
 		return 3
 	case x < 1<<28:
 		return 4
 	case x < 1<<35:
 		return 5
 	case x < 1<<42:
 		return 6
 	case x < 1<<49:
 		return 7
 	case x < 1<<56:
 		return 8
 	case x < 1<<63:
 		return 9
 	}
 	return 10
 }
 // EncodeFixed64 writes a 64-bit integer to the Buffer.
 // This is the format for the
 // fixed64, sfixed64, and double protocol buffer types.
 func (p *Buffer) EncodeFixed64(x uint64) error {
 	p.buf = append(p.buf,
 		uint8(x),
 		uint8(x>>8),
 		uint8(x>>16),
 		uint8(x>>24),
 		uint8(x>>32),
 		uint8(x>>40),
 		uint8(x>>48),
 		uint8(x>>56))
 	return nil
 }
 // EncodeFixed32 writes a 32-bit integer to the Buffer.
 // This is the format for the
 // fixed32, sfixed32, and float protocol buffer types.
 func (p *Buffer) EncodeFixed32(x uint64) error {
 	p.buf = append(p.buf,
 		uint8(x),
 		uint8(x>>8),
 		uint8(x>>16),
 		uint8(x>>24))
 	return nil
 }
 // EncodeZigzag64 writes a zigzag-encoded 64-bit integer
 // to the Buffer.
 // This is the format used for the sint64 protocol buffer type.
 func (p *Buffer) EncodeZigzag64(x uint64) error {
 	// use signed number to get arithmetic right shift.
 	return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
 // EncodeZigzag32 writes a zigzag-encoded 32-bit integer
 // to the Buffer.
 // This is the format used for the sint32 protocol buffer type.
 func (p *Buffer) EncodeZigzag32(x uint64) error {
 	// use signed number to get arithmetic right shift.
 	return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
 }
 // EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
 // This is the format used for the bytes protocol buffer
 // type and for embedded messages.
 func (p *Buffer) EncodeRawBytes(b []byte) error {
 	p.EncodeVarint(uint64(len(b)))
 	p.buf = append(p.buf, b...)
 	return nil
 }
 // EncodeStringBytes writes an encoded string to the Buffer.
 // This is the format used for the proto2 string type.
 func (p *Buffer) EncodeStringBytes(s string) error {
 	p.EncodeVarint(uint64(len(s)))
 	p.buf = append(p.buf, s...)
 	return nil
 }
 // Marshaler is the interface representing objects that can marshal themselves.
 type Marshaler interface {
 	Marshal() ([]byte, error)
 }
 // EncodeMessage writes the protocol buffer to the Buffer,
 // prefixed by a varint-encoded length.
 func (p *Buffer) EncodeMessage(pb Message) error {
 	siz := Size(pb)
 	p.EncodeVarint(uint64(siz))
 	return p.Marshal(pb)
 }
 // All protocol buffer fields are nillable, but be careful.
 func isNil(v reflect.Value) bool {
 	switch v.Kind() {
 	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
 		return v.IsNil()
 	}
 	return false
 }
--- a/vendor/github.com/golang/protobuf/proto/equal.go
+++ b/vendor/github.com/golang/protobuf/proto/equal.go
@@ -0,0 +1,300 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2011 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // 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.
 // Protocol buffer comparison.
 package proto
 import (
 	"bytes"
 	"log"
 	"reflect"
 	"strings"
 )
 /*
 Equal returns true iff protocol buffers a and b are equal.
 The arguments must both be pointers to protocol buffer structs.
 Equality is defined in this way:
  - Two messages are equal iff they are the same type,
    corresponding fields are equal, unknown field sets
    are equal, and extensions sets are equal.
  - Two set scalar fields are equal iff their values are equal.
    If the fields are of a floating-point type, remember that
    NaN != x for all x, including NaN. If the message is defined
    in a proto3 .proto file, fields are not "set"; specifically,
    zero length proto3 "bytes" fields are equal (nil == {}).
  - Two repeated fields are equal iff their lengths are the same,
    and their corresponding elements are equal. Note a "bytes" field,
    although represented by []byte, is not a repeated field and the
    rule for the scalar fields described above applies.
  - Two unset fields are equal.
  - Two unknown field sets are equal if their current
    encoded state is equal.
  - Two extension sets are equal iff they have corresponding
    elements that are pairwise equal.
  - Two map fields are equal iff their lengths are the same,
    and they contain the same set of elements. Zero-length map
    fields are equal.
  - Every other combination of things are not equal.
 The return value is undefined if a and b are not protocol buffers.
 */
 func Equal(a, b Message) bool {
 	if a == nil || b == nil {
 		return a == b
 	}
 	v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
 	if v1.Type() != v2.Type() {
 		return false
 	}
 	if v1.Kind() == reflect.Ptr {
 		if v1.IsNil() {
 			return v2.IsNil()
 		}
 		if v2.IsNil() {
 			return false
 		}
 		v1, v2 = v1.Elem(), v2.Elem()
 	}
 	if v1.Kind() != reflect.Struct {
 		return false
 	}
 	return equalStruct(v1, v2)
 }
 // v1 and v2 are known to have the same type.
 func equalStruct(v1, v2 reflect.Value) bool {
 	sprop := GetProperties(v1.Type())
 	for i := 0; i < v1.NumField(); i++ {
 		f := v1.Type().Field(i)
 		if strings.HasPrefix(f.Name, "XXX_") {
 			continue
 		}
 		f1, f2 := v1.Field(i), v2.Field(i)
 		if f.Type.Kind() == reflect.Ptr {
 			if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
 				// both unset
 				continue
 			} else if n1 != n2 {
 				// set/unset mismatch
 				return false
 			}
 			f1, f2 = f1.Elem(), f2.Elem()
 		}
 		if !equalAny(f1, f2, sprop.Prop[i]) {
 			return false
 		}
 	}
 	if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
 		em2 := v2.FieldByName("XXX_InternalExtensions")
 		if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
 			return false
 		}
 	}
 	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
 		em2 := v2.FieldByName("XXX_extensions")
 		if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
 			return false
 		}
 	}
 	uf := v1.FieldByName("XXX_unrecognized")
 	if !uf.IsValid() {
 		return true
 	}
 	u1 := uf.Bytes()
 	u2 := v2.FieldByName("XXX_unrecognized").Bytes()
 	return bytes.Equal(u1, u2)
 }
 // v1 and v2 are known to have the same type.
 // prop may be nil.
 func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
 	if v1.Type() == protoMessageType {
 		m1, _ := v1.Interface().(Message)
 		m2, _ := v2.Interface().(Message)
 		return Equal(m1, m2)
 	}
 	switch v1.Kind() {
 	case reflect.Bool:
 		return v1.Bool() == v2.Bool()
 	case reflect.Float32, reflect.Float64:
 		return v1.Float() == v2.Float()
 	case reflect.Int32, reflect.Int64:
 		return v1.Int() == v2.Int()
 	case reflect.Interface:
 		// Probably a oneof field; compare the inner values.
 		n1, n2 := v1.IsNil(), v2.IsNil()
 		if n1 || n2 {
 			return n1 == n2
 		}
 		e1, e2 := v1.Elem(), v2.Elem()
 		if e1.Type() != e2.Type() {
 			return false
 		}
 		return equalAny(e1, e2, nil)
 	case reflect.Map:
 		if v1.Len() != v2.Len() {
 			return false
 		}
 		for _, key := range v1.MapKeys() {
 			val2 := v2.MapIndex(key)
 			if !val2.IsValid() {
 				// This key was not found in the second map.
 				return false
 			}
 			if !equalAny(v1.MapIndex(key), val2, nil) {
 				return false
 			}
 		}
 		return true
 	case reflect.Ptr:
 		// Maps may have nil values in them, so check for nil.
 		if v1.IsNil() && v2.IsNil() {
 			return true
 		}
 		if v1.IsNil() != v2.IsNil() {
 			return false
 		}
 		return equalAny(v1.Elem(), v2.Elem(), prop)
 	case reflect.Slice:
 		if v1.Type().Elem().Kind() == reflect.Uint8 {
 			// short circuit: []byte
 			// Edge case: if this is in a proto3 message, a zero length
 			// bytes field is considered the zero value.
 			if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
 				return true
 			}
 			if v1.IsNil() != v2.IsNil() {
 				return false
 			}
 			return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
 		}
 		if v1.Len() != v2.Len() {
 			return false
 		}
 		for i := 0; i < v1.Len(); i++ {
 			if !equalAny(v1.Index(i), v2.Index(i), prop) {
 				return false
 			}
 		}
 		return true
 	case reflect.String:
 		return v1.Interface().(string) == v2.Interface().(string)
 	case reflect.Struct:
 		return equalStruct(v1, v2)
 	case reflect.Uint32, reflect.Uint64:
 		return v1.Uint() == v2.Uint()
 	}
 	// unknown type, so not a protocol buffer
 	log.Printf("proto: don't know how to compare %v", v1)
 	return false
 }
 // base is the struct type that the extensions are based on.
 // x1 and x2 are InternalExtensions.
 func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
 	em1, _ := x1.extensionsRead()
 	em2, _ := x2.extensionsRead()
 	return equalExtMap(base, em1, em2)
 }
 func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
 	if len(em1) != len(em2) {
 		return false
 	}
 	for extNum, e1 := range em1 {
 		e2, ok := em2[extNum]
 		if !ok {
 			return false
 		}
 		m1, m2 := e1.value, e2.value
 		if m1 == nil && m2 == nil {
 			// Both have only encoded form.
 			if bytes.Equal(e1.enc, e2.enc) {
 				continue
 			}
 			// The bytes are different, but the extensions might still be
 			// equal. We need to decode them to compare.
 		}
 		if m1 != nil && m2 != nil {
 			// Both are unencoded.
 			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
 				return false
 			}
 			continue
 		}
 		// At least one is encoded. To do a semantically correct comparison
 		// we need to unmarshal them first.
 		var desc *ExtensionDesc
 		if m := extensionMaps[base]; m != nil {
 			desc = m[extNum]
 		}
 		if desc == nil {
 			// If both have only encoded form and the bytes are the same,
 			// it is handled above. We get here when the bytes are different.
 			// We don't know how to decode it, so just compare them as byte
 			// slices.
 			log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
 			return false
 		}
 		var err error
 		if m1 == nil {
 			m1, err = decodeExtension(e1.enc, desc)
 		}
 		if m2 == nil && err == nil {
 			m2, err = decodeExtension(e2.enc, desc)
 		}
 		if err != nil {
 			// The encoded form is invalid.
 			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
 			return false
 		}
 		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
 			return false
 		}
 	}
 	return true
 }
--- a/vendor/github.com/golang/protobuf/proto/extensions.go
+++ b/vendor/github.com/golang/protobuf/proto/extensions.go
@@ -0,0 +1,543 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2010 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 /*
 * Types and routines for supporting protocol buffer extensions.
 */
 import (
 	"errors"
 	"fmt"
 	"io"
 	"reflect"
 	"strconv"
 	"sync"
 )
 // ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
 var ErrMissingExtension = errors.New("proto: missing extension")
 // ExtensionRange represents a range of message extensions for a protocol buffer.
 // Used in code generated by the protocol compiler.
 type ExtensionRange struct {
 	Start, End int32 // both inclusive
 }
 // extendableProto is an interface implemented by any protocol buffer generated by the current
 // proto compiler that may be extended.
 type extendableProto interface {
 	Message
 	ExtensionRangeArray() []ExtensionRange
 	extensionsWrite() map[int32]Extension
 	extensionsRead() (map[int32]Extension, sync.Locker)
 }
 // extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
 // version of the proto compiler that may be extended.
 type extendableProtoV1 interface {
 	Message
 	ExtensionRangeArray() []ExtensionRange
 	ExtensionMap() map[int32]Extension
 }
 // extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
 type extensionAdapter struct {
 	extendableProtoV1
 }
 func (e extensionAdapter) extensionsWrite() map[int32]Extension {
 	return e.ExtensionMap()
 }
 func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
 	return e.ExtensionMap(), notLocker{}
 }
 // notLocker is a sync.Locker whose Lock and Unlock methods are nops.
 type notLocker struct{}
 func (n notLocker) Lock()   {}
 func (n notLocker) Unlock() {}
 // extendable returns the extendableProto interface for the given generated proto message.
 // If the proto message has the old extension format, it returns a wrapper that implements
 // the extendableProto interface.
 func extendable(p interface{}) (extendableProto, error) {
 	switch p := p.(type) {
 	case extendableProto:
 		if isNilPtr(p) {
 			return nil, fmt.Errorf("proto: nil %T is not extendable", p)
 		}
 		return p, nil
 	case extendableProtoV1:
 		if isNilPtr(p) {
 			return nil, fmt.Errorf("proto: nil %T is not extendable", p)
 		}
 		return extensionAdapter{p}, nil
 	}
 	// Don't allocate a specific error containing %T:
 	// this is the hot path for Clone and MarshalText.
 	return nil, errNotExtendable
 }
 var errNotExtendable = errors.New("proto: not an extendable proto.Message")
 func isNilPtr(x interface{}) bool {
 	v := reflect.ValueOf(x)
 	return v.Kind() == reflect.Ptr && v.IsNil()
 }
 // XXX_InternalExtensions is an internal representation of proto extensions.
 //
 // Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
 // thus gaining the unexported 'extensions' method, which can be called only from the proto package.
 //
 // The methods of XXX_InternalExtensions are not concurrency safe in general,
 // but calls to logically read-only methods such as has and get may be executed concurrently.
 type XXX_InternalExtensions struct {
 	// The struct must be indirect so that if a user inadvertently copies a
 	// generated message and its embedded XXX_InternalExtensions, they
 	// avoid the mayhem of a copied mutex.
 	//
 	// The mutex serializes all logically read-only operations to p.extensionMap.
 	// It is up to the client to ensure that write operations to p.extensionMap are
 	// mutually exclusive with other accesses.
 	p *struct {
 		mu           sync.Mutex
 		extensionMap map[int32]Extension
 	}
 }
 // extensionsWrite returns the extension map, creating it on first use.
 func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
 	if e.p == nil {
 		e.p = new(struct {
 			mu           sync.Mutex
 			extensionMap map[int32]Extension
 		})
 		e.p.extensionMap = make(map[int32]Extension)
 	}
 	return e.p.extensionMap
 }
 // extensionsRead returns the extensions map for read-only use.  It may be nil.
 // The caller must hold the returned mutex's lock when accessing Elements within the map.
 func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
 	if e.p == nil {
 		return nil, nil
 	}
 	return e.p.extensionMap, &e.p.mu
 }
 // ExtensionDesc represents an extension specification.
 // Used in generated code from the protocol compiler.
 type ExtensionDesc struct {
 	ExtendedType  Message     // nil pointer to the type that is being extended
 	ExtensionType interface{} // nil pointer to the extension type
 	Field         int32       // field number
 	Name          string      // fully-qualified name of extension, for text formatting
 	Tag           string      // protobuf tag style
 	Filename      string      // name of the file in which the extension is defined
 }
 func (ed *ExtensionDesc) repeated() bool {
 	t := reflect.TypeOf(ed.ExtensionType)
 	return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
 }
 // Extension represents an extension in a message.
 type Extension struct {
 	// When an extension is stored in a message using SetExtension
 	// only desc and value are set. When the message is marshaled
 	// enc will be set to the encoded form of the message.
 	//
 	// When a message is unmarshaled and contains extensions, each
 	// extension will have only enc set. When such an extension is
 	// accessed using GetExtension (or GetExtensions) desc and value
 	// will be set.
 	desc  *ExtensionDesc
 	value interface{}
 	enc   []byte
 }
 // SetRawExtension is for testing only.
 func SetRawExtension(base Message, id int32, b []byte) {
 	epb, err := extendable(base)
 	if err != nil {
 		return
 	}
 	extmap := epb.extensionsWrite()
 	extmap[id] = Extension{enc: b}
 }
 // isExtensionField returns true iff the given field number is in an extension range.
 func isExtensionField(pb extendableProto, field int32) bool {
 	for _, er := range pb.ExtensionRangeArray() {
 		if er.Start <= field && field <= er.End {
 			return true
 		}
 	}
 	return false
 }
 // checkExtensionTypes checks that the given extension is valid for pb.
 func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
 	var pbi interface{} = pb
 	// Check the extended type.
 	if ea, ok := pbi.(extensionAdapter); ok {
 		pbi = ea.extendableProtoV1
 	}
 	if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
 		return fmt.Errorf("proto: bad extended type; %v does not extend %v", b, a)
 	}
 	// Check the range.
 	if !isExtensionField(pb, extension.Field) {
 		return errors.New("proto: bad extension number; not in declared ranges")
 	}
 	return nil
 }
 // extPropKey is sufficient to uniquely identify an extension.
 type extPropKey struct {
 	base  reflect.Type
 	field int32
 }
 var extProp = struct {
 	sync.RWMutex
 	m map[extPropKey]*Properties
 }{
 	m: make(map[extPropKey]*Properties),
 }
 func extensionProperties(ed *ExtensionDesc) *Properties {
 	key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
 	extProp.RLock()
 	if prop, ok := extProp.m[key]; ok {
 		extProp.RUnlock()
 		return prop
 	}
 	extProp.RUnlock()
 	extProp.Lock()
 	defer extProp.Unlock()
 	// Check again.
 	if prop, ok := extProp.m[key]; ok {
 		return prop
 	}
 	prop := new(Properties)
 	prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
 	extProp.m[key] = prop
 	return prop
 }
 // HasExtension returns whether the given extension is present in pb.
 func HasExtension(pb Message, extension *ExtensionDesc) bool {
 	// TODO: Check types, field numbers, etc.?
 	epb, err := extendable(pb)
 	if err != nil {
 		return false
 	}
 	extmap, mu := epb.extensionsRead()
 	if extmap == nil {
 		return false
 	}
 	mu.Lock()
 	_, ok := extmap[extension.Field]
 	mu.Unlock()
 	return ok
 }
 // ClearExtension removes the given extension from pb.
 func ClearExtension(pb Message, extension *ExtensionDesc) {
 	epb, err := extendable(pb)
 	if err != nil {
 		return
 	}
 	// TODO: Check types, field numbers, etc.?
 	extmap := epb.extensionsWrite()
 	delete(extmap, extension.Field)
 }
 // GetExtension retrieves a proto2 extended field from pb.
 //
 // If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil),
 // then GetExtension parses the encoded field and returns a Go value of the specified type.
 // If the field is not present, then the default value is returned (if one is specified),
 // otherwise ErrMissingExtension is reported.
 //
 // If the descriptor is not type complete (i.e., ExtensionDesc.ExtensionType is nil),
 // then GetExtension returns the raw encoded bytes of the field extension.
 func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
 	epb, err := extendable(pb)
 	if err != nil {
 		return nil, err
 	}
 	if extension.ExtendedType != nil {
 		// can only check type if this is a complete descriptor
 		if err := checkExtensionTypes(epb, extension); err != nil {
 			return nil, err
 		}
 	}
 	emap, mu := epb.extensionsRead()
 	if emap == nil {
 		return defaultExtensionValue(extension)
 	}
 	mu.Lock()
 	defer mu.Unlock()
 	e, ok := emap[extension.Field]
 	if !ok {
 		// defaultExtensionValue returns the default value or
 		// ErrMissingExtension if there is no default.
 		return defaultExtensionValue(extension)
 	}
 	if e.value != nil {
 		// Already decoded. Check the descriptor, though.
 		if e.desc != extension {
 			// This shouldn't happen. If it does, it means that
 			// GetExtension was called twice with two different
 			// descriptors with the same field number.
 			return nil, errors.New("proto: descriptor conflict")
 		}
 		return e.value, nil
 	}
 	if extension.ExtensionType == nil {
 		// incomplete descriptor
 		return e.enc, nil
 	}
 	v, err := decodeExtension(e.enc, extension)
 	if err != nil {
 		return nil, err
 	}
 	// Remember the decoded version and drop the encoded version.
 	// That way it is safe to mutate what we return.
 	e.value = v
 	e.desc = extension
 	e.enc = nil
 	emap[extension.Field] = e
 	return e.value, nil
 }
 // defaultExtensionValue returns the default value for extension.
 // If no default for an extension is defined ErrMissingExtension is returned.
 func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
 	if extension.ExtensionType == nil {
 		// incomplete descriptor, so no default
 		return nil, ErrMissingExtension
 	}
 	t := reflect.TypeOf(extension.ExtensionType)
 	props := extensionProperties(extension)
 	sf, _, err := fieldDefault(t, props)
 	if err != nil {
 		return nil, err
 	}
 	if sf == nil || sf.value == nil {
 		// There is no default value.
 		return nil, ErrMissingExtension
 	}
 	if t.Kind() != reflect.Ptr {
 		// We do not need to return a Ptr, we can directly return sf.value.
 		return sf.value, nil
 	}
 	// We need to return an interface{} that is a pointer to sf.value.
 	value := reflect.New(t).Elem()
 	value.Set(reflect.New(value.Type().Elem()))
 	if sf.kind == reflect.Int32 {
 		// We may have an int32 or an enum, but the underlying data is int32.
 		// Since we can't set an int32 into a non int32 reflect.value directly
 		// set it as a int32.
 		value.Elem().SetInt(int64(sf.value.(int32)))
 	} else {
 		value.Elem().Set(reflect.ValueOf(sf.value))
 	}
 	return value.Interface(), nil
 }
 // decodeExtension decodes an extension encoded in b.
 func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
 	t := reflect.TypeOf(extension.ExtensionType)
 	unmarshal := typeUnmarshaler(t, extension.Tag)
 	// t is a pointer to a struct, pointer to basic type or a slice.
 	// Allocate space to store the pointer/slice.
 	value := reflect.New(t).Elem()
 	var err error
 	for {
 		x, n := decodeVarint(b)
 		if n == 0 {
 			return nil, io.ErrUnexpectedEOF
 		}
 		b = b[n:]
 		wire := int(x) & 7
 		b, err = unmarshal(b, valToPointer(value.Addr()), wire)
 		if err != nil {
 			return nil, err
 		}
 		if len(b) == 0 {
 			break
 		}
 	}
 	return value.Interface(), nil
 }
 // GetExtensions returns a slice of the extensions present in pb that are also listed in es.
 // The returned slice has the same length as es; missing extensions will appear as nil elements.
 func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
 	epb, err := extendable(pb)
 	if err != nil {
 		return nil, err
 	}
 	extensions = make([]interface{}, len(es))
 	for i, e := range es {
 		extensions[i], err = GetExtension(epb, e)
 		if err == ErrMissingExtension {
 			err = nil
 		}
 		if err != nil {
 			return
 		}
 	}
 	return
 }
 // ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
 // For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
 // just the Field field, which defines the extension's field number.
 func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
 	epb, err := extendable(pb)
 	if err != nil {
 		return nil, err
 	}
 	registeredExtensions := RegisteredExtensions(pb)
 	emap, mu := epb.extensionsRead()
 	if emap == nil {
 		return nil, nil
 	}
 	mu.Lock()
 	defer mu.Unlock()
 	extensions := make([]*ExtensionDesc, 0, len(emap))
 	for extid, e := range emap {
 		desc := e.desc
 		if desc == nil {
 			desc = registeredExtensions[extid]
 			if desc == nil {
 				desc = &ExtensionDesc{Field: extid}
 			}
 		}
 		extensions = append(extensions, desc)
 	}
 	return extensions, nil
 }
 // SetExtension sets the specified extension of pb to the specified value.
 func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
 	epb, err := extendable(pb)
 	if err != nil {
 		return err
 	}
 	if err := checkExtensionTypes(epb, extension); err != nil {
 		return err
 	}
 	typ := reflect.TypeOf(extension.ExtensionType)
 	if typ != reflect.TypeOf(value) {
 		return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", value, extension.ExtensionType)
 	}
 	// nil extension values need to be caught early, because the
 	// encoder can't distinguish an ErrNil due to a nil extension
 	// from an ErrNil due to a missing field. Extensions are
 	// always optional, so the encoder would just swallow the error
 	// and drop all the extensions from the encoded message.
 	if reflect.ValueOf(value).IsNil() {
 		return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
 	}
 	extmap := epb.extensionsWrite()
 	extmap[extension.Field] = Extension{desc: extension, value: value}
 	return nil
 }
 // ClearAllExtensions clears all extensions from pb.
 func ClearAllExtensions(pb Message) {
 	epb, err := extendable(pb)
 	if err != nil {
 		return
 	}
 	m := epb.extensionsWrite()
 	for k := range m {
 		delete(m, k)
 	}
 }
 // A global registry of extensions.
 // The generated code will register the generated descriptors by calling RegisterExtension.
 var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
 // RegisterExtension is called from the generated code.
 func RegisterExtension(desc *ExtensionDesc) {
 	st := reflect.TypeOf(desc.ExtendedType).Elem()
 	m := extensionMaps[st]
 	if m == nil {
 		m = make(map[int32]*ExtensionDesc)
 		extensionMaps[st] = m
 	}
 	if _, ok := m[desc.Field]; ok {
 		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
 	}
 	m[desc.Field] = desc
 }
 // RegisteredExtensions returns a map of the registered extensions of a
 // protocol buffer struct, indexed by the extension number.
 // The argument pb should be a nil pointer to the struct type.
 func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
 	return extensionMaps[reflect.TypeOf(pb).Elem()]
 }
--- a/vendor/github.com/golang/protobuf/proto/lib.go
+++ b/vendor/github.com/golang/protobuf/proto/lib.go
@@ -0,0 +1,959 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2010 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /*
 Package proto converts data structures to and from the wire format of
 protocol buffers.  It works in concert with the Go source code generated
 for .proto files by the protocol compiler.
 A summary of the properties of the protocol buffer interface
 for a protocol buffer variable v:
  - Names are turned from camel_case to CamelCase for export.
  - There are no methods on v to set fields; just treat
 	them as structure fields.
  - There are getters that return a field's value if set,
 	and return the field's default value if unset.
 	The getters work even if the receiver is a nil message.
  - The zero value for a struct is its correct initialization state.
 	All desired fields must be set before marshaling.
  - A Reset() method will restore a protobuf struct to its zero state.
  - Non-repeated fields are pointers to the values; nil means unset.
 	That is, optional or required field int32 f becomes F *int32.
  - Repeated fields are slices.
  - Helper functions are available to aid the setting of fields.
 	msg.Foo = proto.String("hello") // set field
  - Constants are defined to hold the default values of all fields that
 	have them.  They have the form Default_StructName_FieldName.
 	Because the getter methods handle defaulted values,
 	direct use of these constants should be rare.
  - Enums are given type names and maps from names to values.
 	Enum values are prefixed by the enclosing message's name, or by the
 	enum's type name if it is a top-level enum. Enum types have a String
 	method, and a Enum method to assist in message construction.
  - Nested messages, groups and enums have type names prefixed with the name of
 	the surrounding message type.
  - Extensions are given descriptor names that start with E_,
 	followed by an underscore-delimited list of the nested messages
 	that contain it (if any) followed by the CamelCased name of the
 	extension field itself.  HasExtension, ClearExtension, GetExtension
 	and SetExtension are functions for manipulating extensions.
  - Oneof field sets are given a single field in their message,
 	with distinguished wrapper types for each possible field value.
  - Marshal and Unmarshal are functions to encode and decode the wire format.
 When the .proto file specifies `syntax="proto3"`, there are some differences:
  - Non-repeated fields of non-message type are values instead of pointers.
  - Enum types do not get an Enum method.
 The simplest way to describe this is to see an example.
 Given file test.proto, containing
 	package example;
 	enum FOO { X = 17; }
 	message Test {
 	  required string label = 1;
 	  optional int32 type = 2 [default=77];
 	  repeated int64 reps = 3;
 	  optional group OptionalGroup = 4 {
 	    required string RequiredField = 5;
 	  }
 	  oneof union {
 	    int32 number = 6;
 	    string name = 7;
 	  }
 	}
 The resulting file, test.pb.go, is:
 	package example
 	import proto "github.com/golang/protobuf/proto"
 	import math "math"
 	type FOO int32
 	const (
 		FOO_X FOO = 17
 	)
 	var FOO_name = map[int32]string{
 		17: "X",
 	}
 	var FOO_value = map[string]int32{
 		"X": 17,
 	}
 	func (x FOO) Enum() *FOO {
 		p := new(FOO)
 		*p = x
 		return p
 	}
 	func (x FOO) String() string {
 		return proto.EnumName(FOO_name, int32(x))
 	}
 	func (x *FOO) UnmarshalJSON(data []byte) error {
 		value, err := proto.UnmarshalJSONEnum(FOO_value, data)
 		if err != nil {
 			return err
 		}
 		*x = FOO(value)
 		return nil
 	}
 	type Test struct {
 		Label         *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
 		Type          *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
 		Reps          []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
 		Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
 		// Types that are valid to be assigned to Union:
 		//	*Test_Number
 		//	*Test_Name
 		Union            isTest_Union `protobuf_oneof:"union"`
 		XXX_unrecognized []byte       `json:"-"`
 	}
 	func (m *Test) Reset()         { *m = Test{} }
 	func (m *Test) String() string { return proto.CompactTextString(m) }
 	func (*Test) ProtoMessage() {}
 	type isTest_Union interface {
 		isTest_Union()
 	}
 	type Test_Number struct {
 		Number int32 `protobuf:"varint,6,opt,name=number"`
 	}
 	type Test_Name struct {
 		Name string `protobuf:"bytes,7,opt,name=name"`
 	}
 	func (*Test_Number) isTest_Union() {}
 	func (*Test_Name) isTest_Union()   {}
 	func (m *Test) GetUnion() isTest_Union {
 		if m != nil {
 			return m.Union
 		}
 		return nil
 	}
 	const Default_Test_Type int32 = 77
 	func (m *Test) GetLabel() string {
 		if m != nil && m.Label != nil {
 			return *m.Label
 		}
 		return ""
 	}
 	func (m *Test) GetType() int32 {
 		if m != nil && m.Type != nil {
 			return *m.Type
 		}
 		return Default_Test_Type
 	}
 	func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
 		if m != nil {
 			return m.Optionalgroup
 		}
 		return nil
 	}
 	type Test_OptionalGroup struct {
 		RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
 	}
 	func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
 	func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
 	func (m *Test_OptionalGroup) GetRequiredField() string {
 		if m != nil && m.RequiredField != nil {
 			return *m.RequiredField
 		}
 		return ""
 	}
 	func (m *Test) GetNumber() int32 {
 		if x, ok := m.GetUnion().(*Test_Number); ok {
 			return x.Number
 		}
 		return 0
 	}
 	func (m *Test) GetName() string {
 		if x, ok := m.GetUnion().(*Test_Name); ok {
 			return x.Name
 		}
 		return ""
 	}
 	func init() {
 		proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
 	}
 To create and play with a Test object:
 	package main
 	import (
 		"log"
 		"github.com/golang/protobuf/proto"
 		pb "./example.pb"
 	)
 	func main() {
 		test := &pb.Test{
 			Label: proto.String("hello"),
 			Type:  proto.Int32(17),
 			Reps:  []int64{1, 2, 3},
 			Optionalgroup: &pb.Test_OptionalGroup{
 				RequiredField: proto.String("good bye"),
 			},
 			Union: &pb.Test_Name{"fred"},
 		}
 		data, err := proto.Marshal(test)
 		if err != nil {
 			log.Fatal("marshaling error: ", err)
 		}
 		newTest := &pb.Test{}
 		err = proto.Unmarshal(data, newTest)
 		if err != nil {
 			log.Fatal("unmarshaling error: ", err)
 		}
 		// Now test and newTest contain the same data.
 		if test.GetLabel() != newTest.GetLabel() {
 			log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
 		}
 		// Use a type switch to determine which oneof was set.
 		switch u := test.Union.(type) {
 		case *pb.Test_Number: // u.Number contains the number.
 		case *pb.Test_Name: // u.Name contains the string.
 		}
 		// etc.
 	}
 */
 package proto
 import (
 	"encoding/json"
 	"fmt"
 	"log"
 	"reflect"
 	"sort"
 	"strconv"
 	"sync"
 )
 // RequiredNotSetError is an error type returned by either Marshal or Unmarshal.
 // Marshal reports this when a required field is not initialized.
 // Unmarshal reports this when a required field is missing from the wire data.
 type RequiredNotSetError struct{ field string }
 func (e *RequiredNotSetError) Error() string {
 	if e.field == "" {
 		return fmt.Sprintf("proto: required field not set")
 	}
 	return fmt.Sprintf("proto: required field %q not set", e.field)
 }
 func (e *RequiredNotSetError) RequiredNotSet() bool {
 	return true
 }
 type invalidUTF8Error struct{ field string }
 func (e *invalidUTF8Error) Error() string {
 	if e.field == "" {
 		return "proto: invalid UTF-8 detected"
 	}
 	return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field)
 }
 func (e *invalidUTF8Error) InvalidUTF8() bool {
 	return true
 }
 // errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8.
 // This error should not be exposed to the external API as such errors should
 // be recreated with the field information.
 var errInvalidUTF8 = &invalidUTF8Error{}
 // isNonFatal reports whether the error is either a RequiredNotSet error
 // or a InvalidUTF8 error.
 func isNonFatal(err error) bool {
 	if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() {
 		return true
 	}
 	if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() {
 		return true
 	}
 	return false
 }
 type nonFatal struct{ E error }
 // Merge merges err into nf and reports whether it was successful.
 // Otherwise it returns false for any fatal non-nil errors.
 func (nf *nonFatal) Merge(err error) (ok bool) {
 	if err == nil {
 		return true // not an error
 	}
 	if !isNonFatal(err) {
 		return false // fatal error
 	}
 	if nf.E == nil {
 		nf.E = err // store first instance of non-fatal error
 	}
 	return true
 }
 // Message is implemented by generated protocol buffer messages.
 type Message interface {
 	Reset()
 	String() string
 	ProtoMessage()
 }
 // A Buffer is a buffer manager for marshaling and unmarshaling
 // protocol buffers.  It may be reused between invocations to
 // reduce memory usage.  It is not necessary to use a Buffer;
 // the global functions Marshal and Unmarshal create a
 // temporary Buffer and are fine for most applications.
 type Buffer struct {
 	buf   []byte // encode/decode byte stream
 	index int    // read point
 	deterministic bool
 }
 // NewBuffer allocates a new Buffer and initializes its internal data to
 // the contents of the argument slice.
 func NewBuffer(e []byte) *Buffer {
 	return &Buffer{buf: e}
 }
 // Reset resets the Buffer, ready for marshaling a new protocol buffer.
 func (p *Buffer) Reset() {
 	p.buf = p.buf[0:0] // for reading/writing
 	p.index = 0        // for reading
 }
 // SetBuf replaces the internal buffer with the slice,
 // ready for unmarshaling the contents of the slice.
 func (p *Buffer) SetBuf(s []byte) {
 	p.buf = s
 	p.index = 0
 }
 // Bytes returns the contents of the Buffer.
 func (p *Buffer) Bytes() []byte { return p.buf }
 // SetDeterministic sets whether to use deterministic serialization.
 //
 // Deterministic serialization guarantees that for a given binary, equal
 // messages will always be serialized to the same bytes. This implies:
 //
 //   - Repeated serialization of a message will return the same bytes.
 //   - Different processes of the same binary (which may be executing on
 //     different machines) will serialize equal messages to the same bytes.
 //
 // Note that the deterministic serialization is NOT canonical across
 // languages. It is not guaranteed to remain stable over time. It is unstable
 // across different builds with schema changes due to unknown fields.
 // Users who need canonical serialization (e.g., persistent storage in a
 // canonical form, fingerprinting, etc.) should define their own
 // canonicalization specification and implement their own serializer rather
 // than relying on this API.
 //
 // If deterministic serialization is requested, map entries will be sorted
 // by keys in lexographical order. This is an implementation detail and
 // subject to change.
 func (p *Buffer) SetDeterministic(deterministic bool) {
 	p.deterministic = deterministic
 }
 /*
 * Helper routines for simplifying the creation of optional fields of basic type.
 */
 // Bool is a helper routine that allocates a new bool value
 // to store v and returns a pointer to it.
 func Bool(v bool) *bool {
 	return &v
 }
 // Int32 is a helper routine that allocates a new int32 value
 // to store v and returns a pointer to it.
 func Int32(v int32) *int32 {
 	return &v
 }
 // Int is a helper routine that allocates a new int32 value
 // to store v and returns a pointer to it, but unlike Int32
 // its argument value is an int.
 func Int(v int) *int32 {
 	p := new(int32)
 	*p = int32(v)
 	return p
 }
 // Int64 is a helper routine that allocates a new int64 value
 // to store v and returns a pointer to it.
 func Int64(v int64) *int64 {
 	return &v
 }
 // Float32 is a helper routine that allocates a new float32 value
 // to store v and returns a pointer to it.
 func Float32(v float32) *float32 {
 	return &v
 }
 // Float64 is a helper routine that allocates a new float64 value
 // to store v and returns a pointer to it.
 func Float64(v float64) *float64 {
 	return &v
 }
 // Uint32 is a helper routine that allocates a new uint32 value
 // to store v and returns a pointer to it.
 func Uint32(v uint32) *uint32 {
 	return &v
 }
 // Uint64 is a helper routine that allocates a new uint64 value
 // to store v and returns a pointer to it.
 func Uint64(v uint64) *uint64 {
 	return &v
 }
 // String is a helper routine that allocates a new string value
 // to store v and returns a pointer to it.
 func String(v string) *string {
 	return &v
 }
 // EnumName is a helper function to simplify printing protocol buffer enums
 // by name.  Given an enum map and a value, it returns a useful string.
 func EnumName(m map[int32]string, v int32) string {
 	s, ok := m[v]
 	if ok {
 		return s
 	}
 	return strconv.Itoa(int(v))
 }
 // UnmarshalJSONEnum is a helper function to simplify recovering enum int values
 // from their JSON-encoded representation. Given a map from the enum's symbolic
 // names to its int values, and a byte buffer containing the JSON-encoded
 // value, it returns an int32 that can be cast to the enum type by the caller.
 //
 // The function can deal with both JSON representations, numeric and symbolic.
 func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
 	if data[0] == '"' {
 		// New style: enums are strings.
 		var repr string
 		if err := json.Unmarshal(data, &repr); err != nil {
 			return -1, err
 		}
 		val, ok := m[repr]
 		if !ok {
 			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
 		}
 		return val, nil
 	}
 	// Old style: enums are ints.
 	var val int32
 	if err := json.Unmarshal(data, &val); err != nil {
 		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
 	}
 	return val, nil
 }
 // DebugPrint dumps the encoded data in b in a debugging format with a header
 // including the string s. Used in testing but made available for general debugging.
 func (p *Buffer) DebugPrint(s string, b []byte) {
 	var u uint64
 	obuf := p.buf
 	index := p.index
 	p.buf = b
 	p.index = 0
 	depth := 0
 	fmt.Printf("\n--- %s ---\n", s)
 out:
 	for {
 		for i := 0; i < depth; i++ {
 			fmt.Print("  ")
 		}
 		index := p.index
 		if index == len(p.buf) {
 			break
 		}
 		op, err := p.DecodeVarint()
 		if err != nil {
 			fmt.Printf("%3d: fetching op err %v\n", index, err)
 			break out
 		}
 		tag := op >> 3
 		wire := op & 7
 		switch wire {
 		default:
 			fmt.Printf("%3d: t=%3d unknown wire=%d\n",
 				index, tag, wire)
 			break out
 		case WireBytes:
 			var r []byte
 			r, err = p.DecodeRawBytes(false)
 			if err != nil {
 				break out
 			}
 			fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
 			if len(r) <= 6 {
 				for i := 0; i < len(r); i++ {
 					fmt.Printf(" %.2x", r[i])
 				}
 			} else {
 				for i := 0; i < 3; i++ {
 					fmt.Printf(" %.2x", r[i])
 				}
 				fmt.Printf(" ..")
 				for i := len(r) - 3; i < len(r); i++ {
 					fmt.Printf(" %.2x", r[i])
 				}
 			}
 			fmt.Printf("\n")
 		case WireFixed32:
 			u, err = p.DecodeFixed32()
 			if err != nil {
 				fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
 				break out
 			}
 			fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
 		case WireFixed64:
 			u, err = p.DecodeFixed64()
 			if err != nil {
 				fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
 				break out
 			}
 			fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
 		case WireVarint:
 			u, err = p.DecodeVarint()
 			if err != nil {
 				fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
 				break out
 			}
 			fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
 		case WireStartGroup:
 			fmt.Printf("%3d: t=%3d start\n", index, tag)
 			depth++
 		case WireEndGroup:
 			depth--
 			fmt.Printf("%3d: t=%3d end\n", index, tag)
 		}
 	}
 	if depth != 0 {
 		fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
 	}
 	fmt.Printf("\n")
 	p.buf = obuf
 	p.index = index
 }
 // SetDefaults sets unset protocol buffer fields to their default values.
 // It only modifies fields that are both unset and have defined defaults.
 // It recursively sets default values in any non-nil sub-messages.
 func SetDefaults(pb Message) {
 	setDefaults(reflect.ValueOf(pb), true, false)
 }
 // v is a pointer to a struct.
 func setDefaults(v reflect.Value, recur, zeros bool) {
 	v = v.Elem()
 	defaultMu.RLock()
 	dm, ok := defaults[v.Type()]
 	defaultMu.RUnlock()
 	if !ok {
 		dm = buildDefaultMessage(v.Type())
 		defaultMu.Lock()
 		defaults[v.Type()] = dm
 		defaultMu.Unlock()
 	}
 	for _, sf := range dm.scalars {
 		f := v.Field(sf.index)
 		if !f.IsNil() {
 			// field already set
 			continue
 		}
 		dv := sf.value
 		if dv == nil && !zeros {
 			// no explicit default, and don't want to set zeros
 			continue
 		}
 		fptr := f.Addr().Interface() // **T
 		// TODO: Consider batching the allocations we do here.
 		switch sf.kind {
 		case reflect.Bool:
 			b := new(bool)
 			if dv != nil {
 				*b = dv.(bool)
 			}
 			*(fptr.(**bool)) = b
 		case reflect.Float32:
 			f := new(float32)
 			if dv != nil {
 				*f = dv.(float32)
 			}
 			*(fptr.(**float32)) = f
 		case reflect.Float64:
 			f := new(float64)
 			if dv != nil {
 				*f = dv.(float64)
 			}
 			*(fptr.(**float64)) = f
 		case reflect.Int32:
 			// might be an enum
 			if ft := f.Type(); ft != int32PtrType {
 				// enum
 				f.Set(reflect.New(ft.Elem()))
 				if dv != nil {
 					f.Elem().SetInt(int64(dv.(int32)))
 				}
 			} else {
 				// int32 field
 				i := new(int32)
 				if dv != nil {
 					*i = dv.(int32)
 				}
 				*(fptr.(**int32)) = i
 			}
 		case reflect.Int64:
 			i := new(int64)
 			if dv != nil {
 				*i = dv.(int64)
 			}
 			*(fptr.(**int64)) = i
 		case reflect.String:
 			s := new(string)
 			if dv != nil {
 				*s = dv.(string)
 			}
 			*(fptr.(**string)) = s
 		case reflect.Uint8:
 			// exceptional case: []byte
 			var b []byte
 			if dv != nil {
 				db := dv.([]byte)
 				b = make([]byte, len(db))
 				copy(b, db)
 			} else {
 				b = []byte{}
 			}
 			*(fptr.(*[]byte)) = b
 		case reflect.Uint32:
 			u := new(uint32)
 			if dv != nil {
 				*u = dv.(uint32)
 			}
 			*(fptr.(**uint32)) = u
 		case reflect.Uint64:
 			u := new(uint64)
 			if dv != nil {
 				*u = dv.(uint64)
 			}
 			*(fptr.(**uint64)) = u
 		default:
 			log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
 		}
 	}
 	for _, ni := range dm.nested {
 		f := v.Field(ni)
 		// f is *T or []*T or map[T]*T
 		switch f.Kind() {
 		case reflect.Ptr:
 			if f.IsNil() {
 				continue
 			}
 			setDefaults(f, recur, zeros)
 		case reflect.Slice:
 			for i := 0; i < f.Len(); i++ {
 				e := f.Index(i)
 				if e.IsNil() {
 					continue
 				}
 				setDefaults(e, recur, zeros)
 			}
 		case reflect.Map:
 			for _, k := range f.MapKeys() {
 				e := f.MapIndex(k)
 				if e.IsNil() {
 					continue
 				}
 				setDefaults(e, recur, zeros)
 			}
 		}
 	}
 }
 var (
 	// defaults maps a protocol buffer struct type to a slice of the fields,
 	// with its scalar fields set to their proto-declared non-zero default values.
 	defaultMu sync.RWMutex
 	defaults  = make(map[reflect.Type]defaultMessage)
 	int32PtrType = reflect.TypeOf((*int32)(nil))
 )
 // defaultMessage represents information about the default values of a message.
 type defaultMessage struct {
 	scalars []scalarField
 	nested  []int // struct field index of nested messages
 }
 type scalarField struct {
 	index int          // struct field index
 	kind  reflect.Kind // element type (the T in *T or []T)
 	value interface{}  // the proto-declared default value, or nil
 }
 // t is a struct type.
 func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
 	sprop := GetProperties(t)
 	for _, prop := range sprop.Prop {
 		fi, ok := sprop.decoderTags.get(prop.Tag)
 		if !ok {
 			// XXX_unrecognized
 			continue
 		}
 		ft := t.Field(fi).Type
 		sf, nested, err := fieldDefault(ft, prop)
 		switch {
 		case err != nil:
 			log.Print(err)
 		case nested:
 			dm.nested = append(dm.nested, fi)
 		case sf != nil:
 			sf.index = fi
 			dm.scalars = append(dm.scalars, *sf)
 		}
 	}
 	return dm
 }
 // fieldDefault returns the scalarField for field type ft.
 // sf will be nil if the field can not have a default.
 // nestedMessage will be true if this is a nested message.
 // Note that sf.index is not set on return.
 func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
 	var canHaveDefault bool
 	switch ft.Kind() {
 	case reflect.Ptr:
 		if ft.Elem().Kind() == reflect.Struct {
 			nestedMessage = true
 		} else {
 			canHaveDefault = true // proto2 scalar field
 		}
 	case reflect.Slice:
 		switch ft.Elem().Kind() {
 		case reflect.Ptr:
 			nestedMessage = true // repeated message
 		case reflect.Uint8:
 			canHaveDefault = true // bytes field
 		}
 	case reflect.Map:
 		if ft.Elem().Kind() == reflect.Ptr {
 			nestedMessage = true // map with message values
 		}
 	}
 	if !canHaveDefault {
 		if nestedMessage {
 			return nil, true, nil
 		}
 		return nil, false, nil
 	}
 	// We now know that ft is a pointer or slice.
 	sf = &scalarField{kind: ft.Elem().Kind()}
 	// scalar fields without defaults
 	if !prop.HasDefault {
 		return sf, false, nil
 	}
 	// a scalar field: either *T or []byte
 	switch ft.Elem().Kind() {
 	case reflect.Bool:
 		x, err := strconv.ParseBool(prop.Default)
 		if err != nil {
 			return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
 		}
 		sf.value = x
 	case reflect.Float32:
 		x, err := strconv.ParseFloat(prop.Default, 32)
 		if err != nil {
 			return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
 		}
 		sf.value = float32(x)
 	case reflect.Float64:
 		x, err := strconv.ParseFloat(prop.Default, 64)
 		if err != nil {
 			return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
 		}
 		sf.value = x
 	case reflect.Int32:
 		x, err := strconv.ParseInt(prop.Default, 10, 32)
 		if err != nil {
 			return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
 		}
 		sf.value = int32(x)
 	case reflect.Int64:
 		x, err := strconv.ParseInt(prop.Default, 10, 64)
 		if err != nil {
 			return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
 		}
 		sf.value = x
 	case reflect.String:
 		sf.value = prop.Default
 	case reflect.Uint8:
 		// []byte (not *uint8)
 		sf.value = []byte(prop.Default)
 	case reflect.Uint32:
 		x, err := strconv.ParseUint(prop.Default, 10, 32)
 		if err != nil {
 			return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
 		}
 		sf.value = uint32(x)
 	case reflect.Uint64:
 		x, err := strconv.ParseUint(prop.Default, 10, 64)
 		if err != nil {
 			return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
 		}
 		sf.value = x
 	default:
 		return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
 	}
 	return sf, false, nil
 }
 // mapKeys returns a sort.Interface to be used for sorting the map keys.
 // Map fields may have key types of non-float scalars, strings and enums.
 func mapKeys(vs []reflect.Value) sort.Interface {
 	s := mapKeySorter{vs: vs}
 	// Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps.
 	if len(vs) == 0 {
 		return s
 	}
 	switch vs[0].Kind() {
 	case reflect.Int32, reflect.Int64:
 		s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
 	case reflect.Uint32, reflect.Uint64:
 		s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
 	case reflect.Bool:
 		s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true
 	case reflect.String:
 		s.less = func(a, b reflect.Value) bool { return a.String() < b.String() }
 	default:
 		panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind()))
 	}
 	return s
 }
 type mapKeySorter struct {
 	vs   []reflect.Value
 	less func(a, b reflect.Value) bool
 }
 func (s mapKeySorter) Len() int      { return len(s.vs) }
 func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
 func (s mapKeySorter) Less(i, j int) bool {
 	return s.less(s.vs[i], s.vs[j])
 }
 // isProto3Zero reports whether v is a zero proto3 value.
 func isProto3Zero(v reflect.Value) bool {
 	switch v.Kind() {
 	case reflect.Bool:
 		return !v.Bool()
 	case reflect.Int32, reflect.Int64:
 		return v.Int() == 0
 	case reflect.Uint32, reflect.Uint64:
 		return v.Uint() == 0
 	case reflect.Float32, reflect.Float64:
 		return v.Float() == 0
 	case reflect.String:
 		return v.String() == ""
 	}
 	return false
 }
 // ProtoPackageIsVersion2 is referenced from generated protocol buffer files
 // to assert that that code is compatible with this version of the proto package.
 const ProtoPackageIsVersion2 = true
 // ProtoPackageIsVersion1 is referenced from generated protocol buffer files
 // to assert that that code is compatible with this version of the proto package.
 const ProtoPackageIsVersion1 = true
 // InternalMessageInfo is a type used internally by generated .pb.go files.
 // This type is not intended to be used by non-generated code.
 // This type is not subject to any compatibility guarantee.
 type InternalMessageInfo struct {
 	marshal   *marshalInfo
 	unmarshal *unmarshalInfo
 	merge     *mergeInfo
 	discard   *discardInfo
 }
--- a/vendor/github.com/golang/protobuf/proto/message_set.go
+++ b/vendor/github.com/golang/protobuf/proto/message_set.go
@@ -0,0 +1,314 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2010 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 /*
 * Support for message sets.
 */
 import (
 	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
 	"sort"
 	"sync"
 )
 // errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
 // A message type ID is required for storing a protocol buffer in a message set.
 var errNoMessageTypeID = errors.New("proto does not have a message type ID")
 // The first two types (_MessageSet_Item and messageSet)
 // model what the protocol compiler produces for the following protocol message:
 //   message MessageSet {
 //     repeated group Item = 1 {
 //       required int32 type_id = 2;
 //       required string message = 3;
 //     };
 //   }
 // That is the MessageSet wire format. We can't use a proto to generate these
 // because that would introduce a circular dependency between it and this package.
 type _MessageSet_Item struct {
 	TypeId  *int32 `protobuf:"varint,2,req,name=type_id"`
 	Message []byte `protobuf:"bytes,3,req,name=message"`
 }
 type messageSet struct {
 	Item             []*_MessageSet_Item `protobuf:"group,1,rep"`
 	XXX_unrecognized []byte
 	// TODO: caching?
 }
 // Make sure messageSet is a Message.
 var _ Message = (*messageSet)(nil)
 // messageTypeIder is an interface satisfied by a protocol buffer type
 // that may be stored in a MessageSet.
 type messageTypeIder interface {
 	MessageTypeId() int32
 }
 func (ms *messageSet) find(pb Message) *_MessageSet_Item {
 	mti, ok := pb.(messageTypeIder)
 	if !ok {
 		return nil
 	}
 	id := mti.MessageTypeId()
 	for _, item := range ms.Item {
 		if *item.TypeId == id {
 			return item
 		}
 	}
 	return nil
 }
 func (ms *messageSet) Has(pb Message) bool {
 	return ms.find(pb) != nil
 }
 func (ms *messageSet) Unmarshal(pb Message) error {
 	if item := ms.find(pb); item != nil {
 		return Unmarshal(item.Message, pb)
 	}
 	if _, ok := pb.(messageTypeIder); !ok {
 		return errNoMessageTypeID
 	}
 	return nil // TODO: return error instead?
 }
 func (ms *messageSet) Marshal(pb Message) error {
 	msg, err := Marshal(pb)
 	if err != nil {
 		return err
 	}
 	if item := ms.find(pb); item != nil {
 		// reuse existing item
 		item.Message = msg
 		return nil
 	}
 	mti, ok := pb.(messageTypeIder)
 	if !ok {
 		return errNoMessageTypeID
 	}
 	mtid := mti.MessageTypeId()
 	ms.Item = append(ms.Item, &_MessageSet_Item{
 		TypeId:  &mtid,
 		Message: msg,
 	})
 	return nil
 }
 func (ms *messageSet) Reset()         { *ms = messageSet{} }
 func (ms *messageSet) String() string { return CompactTextString(ms) }
 func (*messageSet) ProtoMessage()     {}
 // Support for the message_set_wire_format message option.
 func skipVarint(buf []byte) []byte {
 	i := 0
 	for ; buf[i]&0x80 != 0; i++ {
 	}
 	return buf[i+1:]
 }
 // MarshalMessageSet encodes the extension map represented by m in the message set wire format.
 // It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
 func MarshalMessageSet(exts interface{}) ([]byte, error) {
 	return marshalMessageSet(exts, false)
 }
 // marshaMessageSet implements above function, with the opt to turn on / off deterministic during Marshal.
 func marshalMessageSet(exts interface{}, deterministic bool) ([]byte, error) {
 	switch exts := exts.(type) {
 	case *XXX_InternalExtensions:
 		var u marshalInfo
 		siz := u.sizeMessageSet(exts)
 		b := make([]byte, 0, siz)
 		return u.appendMessageSet(b, exts, deterministic)
 	case map[int32]Extension:
 		// This is an old-style extension map.
 		// Wrap it in a new-style XXX_InternalExtensions.
 		ie := XXX_InternalExtensions{
 			p: &struct {
 				mu           sync.Mutex
 				extensionMap map[int32]Extension
 			}{
 				extensionMap: exts,
 			},
 		}
 		var u marshalInfo
 		siz := u.sizeMessageSet(&ie)
 		b := make([]byte, 0, siz)
 		return u.appendMessageSet(b, &ie, deterministic)
 	default:
 		return nil, errors.New("proto: not an extension map")
 	}
 }
 // UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
 // It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
 func UnmarshalMessageSet(buf []byte, exts interface{}) error {
 	var m map[int32]Extension
 	switch exts := exts.(type) {
 	case *XXX_InternalExtensions:
 		m = exts.extensionsWrite()
 	case map[int32]Extension:
 		m = exts
 	default:
 		return errors.New("proto: not an extension map")
 	}
 	ms := new(messageSet)
 	if err := Unmarshal(buf, ms); err != nil {
 		return err
 	}
 	for _, item := range ms.Item {
 		id := *item.TypeId
 		msg := item.Message
 		// Restore wire type and field number varint, plus length varint.
 		// Be careful to preserve duplicate items.
 		b := EncodeVarint(uint64(id)<<3 | WireBytes)
 		if ext, ok := m[id]; ok {
 			// Existing data; rip off the tag and length varint
 			// so we join the new data correctly.
 			// We can assume that ext.enc is set because we are unmarshaling.
 			o := ext.enc[len(b):]   // skip wire type and field number
 			_, n := DecodeVarint(o) // calculate length of length varint
 			o = o[n:]               // skip length varint
 			msg = append(o, msg...) // join old data and new data
 		}
 		b = append(b, EncodeVarint(uint64(len(msg)))...)
 		b = append(b, msg...)
 		m[id] = Extension{enc: b}
 	}
 	return nil
 }
 // MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
 // It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
 func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {
 	var m map[int32]Extension
 	switch exts := exts.(type) {
 	case *XXX_InternalExtensions:
 		var mu sync.Locker
 		m, mu = exts.extensionsRead()
 		if m != nil {
 			// Keep the extensions map locked until we're done marshaling to prevent
 			// races between marshaling and unmarshaling the lazily-{en,de}coded
 			// values.
 			mu.Lock()
 			defer mu.Unlock()
 		}
 	case map[int32]Extension:
 		m = exts
 	default:
 		return nil, errors.New("proto: not an extension map")
 	}
 	var b bytes.Buffer
 	b.WriteByte('{')
 	// Process the map in key order for deterministic output.
 	ids := make([]int32, 0, len(m))
 	for id := range m {
 		ids = append(ids, id)
 	}
 	sort.Sort(int32Slice(ids)) // int32Slice defined in text.go
 	for i, id := range ids {
 		ext := m[id]
 		msd, ok := messageSetMap[id]
 		if !ok {
 			// Unknown type; we can't render it, so skip it.
 			continue
 		}
 		if i > 0 && b.Len() > 1 {
 			b.WriteByte(',')
 		}
 		fmt.Fprintf(&b, `"[%s]":`, msd.name)
 		x := ext.value
 		if x == nil {
 			x = reflect.New(msd.t.Elem()).Interface()
 			if err := Unmarshal(ext.enc, x.(Message)); err != nil {
 				return nil, err
 			}
 		}
 		d, err := json.Marshal(x)
 		if err != nil {
 			return nil, err
 		}
 		b.Write(d)
 	}
 	b.WriteByte('}')
 	return b.Bytes(), nil
 }
 // UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
 // It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
 func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error {
 	// Common-case fast path.
 	if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
 		return nil
 	}
 	// This is fairly tricky, and it's not clear that it is needed.
 	return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented")
 }
 // A global registry of types that can be used in a MessageSet.
 var messageSetMap = make(map[int32]messageSetDesc)
 type messageSetDesc struct {
 	t    reflect.Type // pointer to struct
 	name string
 }
 // RegisterMessageSetType is called from the generated code.
 func RegisterMessageSetType(m Message, fieldNum int32, name string) {
 	messageSetMap[fieldNum] = messageSetDesc{
 		t:    reflect.TypeOf(m),
 		name: name,
 	}
 }
--- a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
+++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
@@ -0,0 +1,357 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2012 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // 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.
 // +build purego appengine js
 // This file contains an implementation of proto field accesses using package reflect.
 // It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
 // be used on App Engine.
 package proto
 import (
 	"reflect"
 	"sync"
 )
 const unsafeAllowed = false
 // A field identifies a field in a struct, accessible from a pointer.
 // In this implementation, a field is identified by the sequence of field indices
 // passed to reflect's FieldByIndex.
 type field []int
 // toField returns a field equivalent to the given reflect field.
 func toField(f *reflect.StructField) field {
 	return f.Index
 }
 // invalidField is an invalid field identifier.
 var invalidField = field(nil)
 // zeroField is a noop when calling pointer.offset.
 var zeroField = field([]int{})
 // IsValid reports whether the field identifier is valid.
 func (f field) IsValid() bool { return f != nil }
 // The pointer type is for the table-driven decoder.
 // The implementation here uses a reflect.Value of pointer type to
 // create a generic pointer. In pointer_unsafe.go we use unsafe
 // instead of reflect to implement the same (but faster) interface.
 type pointer struct {
 	v reflect.Value
 }
 // toPointer converts an interface of pointer type to a pointer
 // that points to the same target.
 func toPointer(i *Message) pointer {
 	return pointer{v: reflect.ValueOf(*i)}
 }
 // toAddrPointer converts an interface to a pointer that points to
 // the interface data.
 func toAddrPointer(i *interface{}, isptr bool) pointer {
 	v := reflect.ValueOf(*i)
 	u := reflect.New(v.Type())
 	u.Elem().Set(v)
 	return pointer{v: u}
 }
 // valToPointer converts v to a pointer.  v must be of pointer type.
 func valToPointer(v reflect.Value) pointer {
 	return pointer{v: v}
 }
 // offset converts from a pointer to a structure to a pointer to
 // one of its fields.
 func (p pointer) offset(f field) pointer {
 	return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}
 }
 func (p pointer) isNil() bool {
 	return p.v.IsNil()
 }
 // grow updates the slice s in place to make it one element longer.
 // s must be addressable.
 // Returns the (addressable) new element.
 func grow(s reflect.Value) reflect.Value {
 	n, m := s.Len(), s.Cap()
 	if n < m {
 		s.SetLen(n + 1)
 	} else {
 		s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem())))
 	}
 	return s.Index(n)
 }
 func (p pointer) toInt64() *int64 {
 	return p.v.Interface().(*int64)
 }
 func (p pointer) toInt64Ptr() **int64 {
 	return p.v.Interface().(**int64)
 }
 func (p pointer) toInt64Slice() *[]int64 {
 	return p.v.Interface().(*[]int64)
 }
 var int32ptr = reflect.TypeOf((*int32)(nil))
 func (p pointer) toInt32() *int32 {
 	return p.v.Convert(int32ptr).Interface().(*int32)
 }
 // The toInt32Ptr/Slice methods don't work because of enums.
 // Instead, we must use set/get methods for the int32ptr/slice case.
 /*
 	func (p pointer) toInt32Ptr() **int32 {
 		return p.v.Interface().(**int32)
 }
 	func (p pointer) toInt32Slice() *[]int32 {
 		return p.v.Interface().(*[]int32)
 }
 */
 func (p pointer) getInt32Ptr() *int32 {
 	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
 		// raw int32 type
 		return p.v.Elem().Interface().(*int32)
 	}
 	// an enum
 	return p.v.Elem().Convert(int32PtrType).Interface().(*int32)
 }
 func (p pointer) setInt32Ptr(v int32) {
 	// Allocate value in a *int32. Possibly convert that to a *enum.
 	// Then assign it to a **int32 or **enum.
 	// Note: we can convert *int32 to *enum, but we can't convert
 	// **int32 to **enum!
 	p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem()))
 }
 // getInt32Slice copies []int32 from p as a new slice.
 // This behavior differs from the implementation in pointer_unsafe.go.
 func (p pointer) getInt32Slice() []int32 {
 	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
 		// raw int32 type
 		return p.v.Elem().Interface().([]int32)
 	}
 	// an enum
 	// Allocate a []int32, then assign []enum's values into it.
 	// Note: we can't convert []enum to []int32.
 	slice := p.v.Elem()
 	s := make([]int32, slice.Len())
 	for i := 0; i < slice.Len(); i++ {
 		s[i] = int32(slice.Index(i).Int())
 	}
 	return s
 }
 // setInt32Slice copies []int32 into p as a new slice.
 // This behavior differs from the implementation in pointer_unsafe.go.
 func (p pointer) setInt32Slice(v []int32) {
 	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
 		// raw int32 type
 		p.v.Elem().Set(reflect.ValueOf(v))
 		return
 	}
 	// an enum
 	// Allocate a []enum, then assign []int32's values into it.
 	// Note: we can't convert []enum to []int32.
 	slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v))
 	for i, x := range v {
 		slice.Index(i).SetInt(int64(x))
 	}
 	p.v.Elem().Set(slice)
 }
 func (p pointer) appendInt32Slice(v int32) {
 	grow(p.v.Elem()).SetInt(int64(v))
 }
 func (p pointer) toUint64() *uint64 {
 	return p.v.Interface().(*uint64)
 }
 func (p pointer) toUint64Ptr() **uint64 {
 	return p.v.Interface().(**uint64)
 }
 func (p pointer) toUint64Slice() *[]uint64 {
 	return p.v.Interface().(*[]uint64)
 }
 func (p pointer) toUint32() *uint32 {
 	return p.v.Interface().(*uint32)
 }
 func (p pointer) toUint32Ptr() **uint32 {
 	return p.v.Interface().(**uint32)
 }
 func (p pointer) toUint32Slice() *[]uint32 {
 	return p.v.Interface().(*[]uint32)
 }
 func (p pointer) toBool() *bool {
 	return p.v.Interface().(*bool)
 }
 func (p pointer) toBoolPtr() **bool {
 	return p.v.Interface().(**bool)
 }
 func (p pointer) toBoolSlice() *[]bool {
 	return p.v.Interface().(*[]bool)
 }
 func (p pointer) toFloat64() *float64 {
 	return p.v.Interface().(*float64)
 }
 func (p pointer) toFloat64Ptr() **float64 {
 	return p.v.Interface().(**float64)
 }
 func (p pointer) toFloat64Slice() *[]float64 {
 	return p.v.Interface().(*[]float64)
 }
 func (p pointer) toFloat32() *float32 {
 	return p.v.Interface().(*float32)
 }
 func (p pointer) toFloat32Ptr() **float32 {
 	return p.v.Interface().(**float32)
 }
 func (p pointer) toFloat32Slice() *[]float32 {
 	return p.v.Interface().(*[]float32)
 }
 func (p pointer) toString() *string {
 	return p.v.Interface().(*string)
 }
 func (p pointer) toStringPtr() **string {
 	return p.v.Interface().(**string)
 }
 func (p pointer) toStringSlice() *[]string {
 	return p.v.Interface().(*[]string)
 }
 func (p pointer) toBytes() *[]byte {
 	return p.v.Interface().(*[]byte)
 }
 func (p pointer) toBytesSlice() *[][]byte {
 	return p.v.Interface().(*[][]byte)
 }
 func (p pointer) toExtensions() *XXX_InternalExtensions {
 	return p.v.Interface().(*XXX_InternalExtensions)
 }
 func (p pointer) toOldExtensions() *map[int32]Extension {
 	return p.v.Interface().(*map[int32]Extension)
 }
 func (p pointer) getPointer() pointer {
 	return pointer{v: p.v.Elem()}
 }
 func (p pointer) setPointer(q pointer) {
 	p.v.Elem().Set(q.v)
 }
 func (p pointer) appendPointer(q pointer) {
 	grow(p.v.Elem()).Set(q.v)
 }
 // getPointerSlice copies []*T from p as a new []pointer.
 // This behavior differs from the implementation in pointer_unsafe.go.
 func (p pointer) getPointerSlice() []pointer {
 	if p.v.IsNil() {
 		return nil
 	}
 	n := p.v.Elem().Len()
 	s := make([]pointer, n)
 	for i := 0; i < n; i++ {
 		s[i] = pointer{v: p.v.Elem().Index(i)}
 	}
 	return s
 }
 // setPointerSlice copies []pointer into p as a new []*T.
 // This behavior differs from the implementation in pointer_unsafe.go.
 func (p pointer) setPointerSlice(v []pointer) {
 	if v == nil {
 		p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem())
 		return
 	}
 	s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v))
 	for _, p := range v {
 		s = reflect.Append(s, p.v)
 	}
 	p.v.Elem().Set(s)
 }
 // getInterfacePointer returns a pointer that points to the
 // interface data of the interface pointed by p.
 func (p pointer) getInterfacePointer() pointer {
 	if p.v.Elem().IsNil() {
 		return pointer{v: p.v.Elem()}
 	}
 	return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct
 }
 func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
 	// TODO: check that p.v.Type().Elem() == t?
 	return p.v
 }
 func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
 	atomicLock.Lock()
 	defer atomicLock.Unlock()
 	return *p
 }
 func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
 	atomicLock.Lock()
 	defer atomicLock.Unlock()
 	*p = v
 }
 func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
 	atomicLock.Lock()
 	defer atomicLock.Unlock()
 	return *p
 }
 func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
 	atomicLock.Lock()
 	defer atomicLock.Unlock()
 	*p = v
 }
 func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
 	atomicLock.Lock()
 	defer atomicLock.Unlock()
 	return *p
 }
 func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
 	atomicLock.Lock()
 	defer atomicLock.Unlock()
 	*p = v
 }
 func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
 	atomicLock.Lock()
 	defer atomicLock.Unlock()
 	return *p
 }
 func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
 	atomicLock.Lock()
 	defer atomicLock.Unlock()
 	*p = v
 }
 var atomicLock sync.Mutex
--- a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
+++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
@@ -0,0 +1,308 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2012 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // 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.
 // +build !purego,!appengine,!js
 // This file contains the implementation of the proto field accesses using package unsafe.
 package proto
 import (
 	"reflect"
 	"sync/atomic"
 	"unsafe"
 )
 const unsafeAllowed = true
 // A field identifies a field in a struct, accessible from a pointer.
 // In this implementation, a field is identified by its byte offset from the start of the struct.
 type field uintptr
 // toField returns a field equivalent to the given reflect field.
 func toField(f *reflect.StructField) field {
 	return field(f.Offset)
 }
 // invalidField is an invalid field identifier.
 const invalidField = ^field(0)
 // zeroField is a noop when calling pointer.offset.
 const zeroField = field(0)
 // IsValid reports whether the field identifier is valid.
 func (f field) IsValid() bool {
 	return f != invalidField
 }
 // The pointer type below is for the new table-driven encoder/decoder.
 // The implementation here uses unsafe.Pointer to create a generic pointer.
 // In pointer_reflect.go we use reflect instead of unsafe to implement
 // the same (but slower) interface.
 type pointer struct {
 	p unsafe.Pointer
 }
 // size of pointer
 var ptrSize = unsafe.Sizeof(uintptr(0))
 // toPointer converts an interface of pointer type to a pointer
 // that points to the same target.
 func toPointer(i *Message) pointer {
 	// Super-tricky - read pointer out of data word of interface value.
 	// Saves ~25ns over the equivalent:
 	// return valToPointer(reflect.ValueOf(*i))
 	return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
 }
 // toAddrPointer converts an interface to a pointer that points to
 // the interface data.
 func toAddrPointer(i *interface{}, isptr bool) pointer {
 	// Super-tricky - read or get the address of data word of interface value.
 	if isptr {
 		// The interface is of pointer type, thus it is a direct interface.
 		// The data word is the pointer data itself. We take its address.
 		return pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
 	}
 	// The interface is not of pointer type. The data word is the pointer
 	// to the data.
 	return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
 }
 // valToPointer converts v to a pointer. v must be of pointer type.
 func valToPointer(v reflect.Value) pointer {
 	return pointer{p: unsafe.Pointer(v.Pointer())}
 }
 // offset converts from a pointer to a structure to a pointer to
 // one of its fields.
 func (p pointer) offset(f field) pointer {
 	// For safety, we should panic if !f.IsValid, however calling panic causes
 	// this to no longer be inlineable, which is a serious performance cost.
 	/*
 		if !f.IsValid() {
 			panic("invalid field")
 		}
 	*/
 	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
 }
 func (p pointer) isNil() bool {
 	return p.p == nil
 }
 func (p pointer) toInt64() *int64 {
 	return (*int64)(p.p)
 }
 func (p pointer) toInt64Ptr() **int64 {
 	return (**int64)(p.p)
 }
 func (p pointer) toInt64Slice() *[]int64 {
 	return (*[]int64)(p.p)
 }
 func (p pointer) toInt32() *int32 {
 	return (*int32)(p.p)
 }
 // See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.
 /*
 	func (p pointer) toInt32Ptr() **int32 {
 		return (**int32)(p.p)
 	}
 	func (p pointer) toInt32Slice() *[]int32 {
 		return (*[]int32)(p.p)
 	}
 */
 func (p pointer) getInt32Ptr() *int32 {
 	return *(**int32)(p.p)
 }
 func (p pointer) setInt32Ptr(v int32) {
 	*(**int32)(p.p) = &v
 }
 // getInt32Slice loads a []int32 from p.
 // The value returned is aliased with the original slice.
 // This behavior differs from the implementation in pointer_reflect.go.
 func (p pointer) getInt32Slice() []int32 {
 	return *(*[]int32)(p.p)
 }
 // setInt32Slice stores a []int32 to p.
 // The value set is aliased with the input slice.
 // This behavior differs from the implementation in pointer_reflect.go.
 func (p pointer) setInt32Slice(v []int32) {
 	*(*[]int32)(p.p) = v
 }
 // TODO: Can we get rid of appendInt32Slice and use setInt32Slice instead?
 func (p pointer) appendInt32Slice(v int32) {
 	s := (*[]int32)(p.p)
 	*s = append(*s, v)
 }
 func (p pointer) toUint64() *uint64 {
 	return (*uint64)(p.p)
 }
 func (p pointer) toUint64Ptr() **uint64 {
 	return (**uint64)(p.p)
 }
 func (p pointer) toUint64Slice() *[]uint64 {
 	return (*[]uint64)(p.p)
 }
 func (p pointer) toUint32() *uint32 {
 	return (*uint32)(p.p)
 }
 func (p pointer) toUint32Ptr() **uint32 {
 	return (**uint32)(p.p)
 }
 func (p pointer) toUint32Slice() *[]uint32 {
 	return (*[]uint32)(p.p)
 }
 func (p pointer) toBool() *bool {
 	return (*bool)(p.p)
 }
 func (p pointer) toBoolPtr() **bool {
 	return (**bool)(p.p)
 }
 func (p pointer) toBoolSlice() *[]bool {
 	return (*[]bool)(p.p)
 }
 func (p pointer) toFloat64() *float64 {
 	return (*float64)(p.p)
 }
 func (p pointer) toFloat64Ptr() **float64 {
 	return (**float64)(p.p)
 }
 func (p pointer) toFloat64Slice() *[]float64 {
 	return (*[]float64)(p.p)
 }
 func (p pointer) toFloat32() *float32 {
 	return (*float32)(p.p)
 }
 func (p pointer) toFloat32Ptr() **float32 {
 	return (**float32)(p.p)
 }
 func (p pointer) toFloat32Slice() *[]float32 {
 	return (*[]float32)(p.p)
 }
 func (p pointer) toString() *string {
 	return (*string)(p.p)
 }
 func (p pointer) toStringPtr() **string {
 	return (**string)(p.p)
 }
 func (p pointer) toStringSlice() *[]string {
 	return (*[]string)(p.p)
 }
 func (p pointer) toBytes() *[]byte {
 	return (*[]byte)(p.p)
 }
 func (p pointer) toBytesSlice() *[][]byte {
 	return (*[][]byte)(p.p)
 }
 func (p pointer) toExtensions() *XXX_InternalExtensions {
 	return (*XXX_InternalExtensions)(p.p)
 }
 func (p pointer) toOldExtensions() *map[int32]Extension {
 	return (*map[int32]Extension)(p.p)
 }
 // getPointerSlice loads []*T from p as a []pointer.
 // The value returned is aliased with the original slice.
 // This behavior differs from the implementation in pointer_reflect.go.
 func (p pointer) getPointerSlice() []pointer {
 	// Super-tricky - p should point to a []*T where T is a
 	// message type. We load it as []pointer.
 	return *(*[]pointer)(p.p)
 }
 // setPointerSlice stores []pointer into p as a []*T.
 // The value set is aliased with the input slice.
 // This behavior differs from the implementation in pointer_reflect.go.
 func (p pointer) setPointerSlice(v []pointer) {
 	// Super-tricky - p should point to a []*T where T is a
 	// message type. We store it as []pointer.
 	*(*[]pointer)(p.p) = v
 }
 // getPointer loads the pointer at p and returns it.
 func (p pointer) getPointer() pointer {
 	return pointer{p: *(*unsafe.Pointer)(p.p)}
 }
 // setPointer stores the pointer q at p.
 func (p pointer) setPointer(q pointer) {
 	*(*unsafe.Pointer)(p.p) = q.p
 }
 // append q to the slice pointed to by p.
 func (p pointer) appendPointer(q pointer) {
 	s := (*[]unsafe.Pointer)(p.p)
 	*s = append(*s, q.p)
 }
 // getInterfacePointer returns a pointer that points to the
 // interface data of the interface pointed by p.
 func (p pointer) getInterfacePointer() pointer {
 	// Super-tricky - read pointer out of data word of interface value.
 	return pointer{p: (*(*[2]unsafe.Pointer)(p.p))[1]}
 }
 // asPointerTo returns a reflect.Value that is a pointer to an
 // object of type t stored at p.
 func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
 	return reflect.NewAt(t, p.p)
 }
 func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
 	return (*unmarshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
 }
 func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
 	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
 }
 func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
 	return (*marshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
 }
 func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
 	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
 }
 func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
 	return (*mergeInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
 }
 func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
 	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
 }
 func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
 	return (*discardInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
 }
 func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
 	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
 }
--- a/vendor/github.com/golang/protobuf/proto/properties.go
+++ b/vendor/github.com/golang/protobuf/proto/properties.go
@@ -0,0 +1,535 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2010 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 /*
 * Routines for encoding data into the wire format for protocol buffers.
 */
 import (
 	"fmt"
 	"log"
 	"os"
 	"reflect"
 	"sort"
 	"strconv"
 	"strings"
 	"sync"
 )
 const debug bool = false
 // Constants that identify the encoding of a value on the wire.
 const (
 	WireVarint     = 0
 	WireFixed64    = 1
 	WireBytes      = 2
 	WireStartGroup = 3
 	WireEndGroup   = 4
 	WireFixed32    = 5
 )
 // tagMap is an optimization over map[int]int for typical protocol buffer
 // use-cases. Encoded protocol buffers are often in tag order with small tag
 // numbers.
 type tagMap struct {
 	fastTags []int
 	slowTags map[int]int
 }
 // tagMapFastLimit is the upper bound on the tag number that will be stored in
 // the tagMap slice rather than its map.
 const tagMapFastLimit = 1024
 func (p *tagMap) get(t int) (int, bool) {
 	if t > 0 && t < tagMapFastLimit {
 		if t >= len(p.fastTags) {
 			return 0, false
 		}
 		fi := p.fastTags[t]
 		return fi, fi >= 0
 	}
 	fi, ok := p.slowTags[t]
 	return fi, ok
 }
 func (p *tagMap) put(t int, fi int) {
 	if t > 0 && t < tagMapFastLimit {
 		for len(p.fastTags) < t+1 {
 			p.fastTags = append(p.fastTags, -1)
 		}
 		p.fastTags[t] = fi
 		return
 	}
 	if p.slowTags == nil {
 		p.slowTags = make(map[int]int)
 	}
 	p.slowTags[t] = fi
 }
 // StructProperties represents properties for all the fields of a struct.
 // decoderTags and decoderOrigNames should only be used by the decoder.
 type StructProperties struct {
 	Prop             []*Properties  // properties for each field
 	reqCount         int            // required count
 	decoderTags      tagMap         // map from proto tag to struct field number
 	decoderOrigNames map[string]int // map from original name to struct field number
 	order            []int          // list of struct field numbers in tag order
 	// OneofTypes contains information about the oneof fields in this message.
 	// It is keyed by the original name of a field.
 	OneofTypes map[string]*OneofProperties
 }
 // OneofProperties represents information about a specific field in a oneof.
 type OneofProperties struct {
 	Type  reflect.Type // pointer to generated struct type for this oneof field
 	Field int          // struct field number of the containing oneof in the message
 	Prop  *Properties
 }
 // Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
 // See encode.go, (*Buffer).enc_struct.
 func (sp *StructProperties) Len() int { return len(sp.order) }
 func (sp *StructProperties) Less(i, j int) bool {
 	return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
 }
 func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
 // Properties represents the protocol-specific behavior of a single struct field.
 type Properties struct {
 	Name     string // name of the field, for error messages
 	OrigName string // original name before protocol compiler (always set)
 	JSONName string // name to use for JSON; determined by protoc
 	Wire     string
 	WireType int
 	Tag      int
 	Required bool
 	Optional bool
 	Repeated bool
 	Packed   bool   // relevant for repeated primitives only
 	Enum     string // set for enum types only
 	proto3   bool   // whether this is known to be a proto3 field
 	oneof    bool   // whether this is a oneof field
 	Default    string // default value
 	HasDefault bool   // whether an explicit default was provided
 	stype reflect.Type      // set for struct types only
 	sprop *StructProperties // set for struct types only
 	mtype      reflect.Type // set for map types only
 	MapKeyProp *Properties  // set for map types only
 	MapValProp *Properties  // set for map types only
 }
 // String formats the properties in the protobuf struct field tag style.
 func (p *Properties) String() string {
 	s := p.Wire
 	s += ","
 	s += strconv.Itoa(p.Tag)
 	if p.Required {
 		s += ",req"
 	}
 	if p.Optional {
 		s += ",opt"
 	}
 	if p.Repeated {
 		s += ",rep"
 	}
 	if p.Packed {
 		s += ",packed"
 	}
 	s += ",name=" + p.OrigName
 	if p.JSONName != p.OrigName {
 		s += ",json=" + p.JSONName
 	}
 	if p.proto3 {
 		s += ",proto3"
 	}
 	if p.oneof {
 		s += ",oneof"
 	}
 	if len(p.Enum) > 0 {
 		s += ",enum=" + p.Enum
 	}
 	if p.HasDefault {
 		s += ",def=" + p.Default
 	}
 	return s
 }
 // Parse populates p by parsing a string in the protobuf struct field tag style.
 func (p *Properties) Parse(s string) {
 	// "bytes,49,opt,name=foo,def=hello!"
 	fields := strings.Split(s, ",") // breaks def=, but handled below.
 	if len(fields) < 2 {
 		fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s)
 		return
 	}
 	p.Wire = fields[0]
 	switch p.Wire {
 	case "varint":
 		p.WireType = WireVarint
 	case "fixed32":
 		p.WireType = WireFixed32
 	case "fixed64":
 		p.WireType = WireFixed64
 	case "zigzag32":
 		p.WireType = WireVarint
 	case "zigzag64":
 		p.WireType = WireVarint
 	case "bytes", "group":
 		p.WireType = WireBytes
 		// no numeric converter for non-numeric types
 	default:
 		fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s)
 		return
 	}
 	var err error
 	p.Tag, err = strconv.Atoi(fields[1])
 	if err != nil {
 		return
 	}
 outer:
 	for i := 2; i < len(fields); i++ {
 		f := fields[i]
 		switch {
 		case f == "req":
 			p.Required = true
 		case f == "opt":
 			p.Optional = true
 		case f == "rep":
 			p.Repeated = true
 		case f == "packed":
 			p.Packed = true
 		case strings.HasPrefix(f, "name="):
 			p.OrigName = f[5:]
 		case strings.HasPrefix(f, "json="):
 			p.JSONName = f[5:]
 		case strings.HasPrefix(f, "enum="):
 			p.Enum = f[5:]
 		case f == "proto3":
 			p.proto3 = true
 		case f == "oneof":
 			p.oneof = true
 		case strings.HasPrefix(f, "def="):
 			p.HasDefault = true
 			p.Default = f[4:] // rest of string
 			if i+1 < len(fields) {
 				// Commas aren't escaped, and def is always last.
 				p.Default += "," + strings.Join(fields[i+1:], ",")
 				break outer
 			}
 		}
 	}
 }
 var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
 // setFieldProps initializes the field properties for submessages and maps.
 func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
 	switch t1 := typ; t1.Kind() {
 	case reflect.Ptr:
 		if t1.Elem().Kind() == reflect.Struct {
 			p.stype = t1.Elem()
 		}
 	case reflect.Slice:
 		if t2 := t1.Elem(); t2.Kind() == reflect.Ptr && t2.Elem().Kind() == reflect.Struct {
 			p.stype = t2.Elem()
 		}
 	case reflect.Map:
 		p.mtype = t1
 		p.MapKeyProp = &Properties{}
 		p.MapKeyProp.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
 		p.MapValProp = &Properties{}
 		vtype := p.mtype.Elem()
 		if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
 			// The value type is not a message (*T) or bytes ([]byte),
 			// so we need encoders for the pointer to this type.
 			vtype = reflect.PtrTo(vtype)
 		}
 		p.MapValProp.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
 	}
 	if p.stype != nil {
 		if lockGetProp {
 			p.sprop = GetProperties(p.stype)
 		} else {
 			p.sprop = getPropertiesLocked(p.stype)
 		}
 	}
 }
 var (
 	marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
 )
 // Init populates the properties from a protocol buffer struct tag.
 func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
 	p.init(typ, name, tag, f, true)
 }
 func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
 	// "bytes,49,opt,def=hello!"
 	p.Name = name
 	p.OrigName = name
 	if tag == "" {
 		return
 	}
 	p.Parse(tag)
 	p.setFieldProps(typ, f, lockGetProp)
 }
 var (
 	propertiesMu  sync.RWMutex
 	propertiesMap = make(map[reflect.Type]*StructProperties)
 )
 // GetProperties returns the list of properties for the type represented by t.
 // t must represent a generated struct type of a protocol message.
 func GetProperties(t reflect.Type) *StructProperties {
 	if t.Kind() != reflect.Struct {
 		panic("proto: type must have kind struct")
 	}
 	// Most calls to GetProperties in a long-running program will be
 	// retrieving details for types we have seen before.
 	propertiesMu.RLock()
 	sprop, ok := propertiesMap[t]
 	propertiesMu.RUnlock()
 	if ok {
 		return sprop
 	}
 	propertiesMu.Lock()
 	sprop = getPropertiesLocked(t)
 	propertiesMu.Unlock()
 	return sprop
 }
 // getPropertiesLocked requires that propertiesMu is held.
 func getPropertiesLocked(t reflect.Type) *StructProperties {
 	if prop, ok := propertiesMap[t]; ok {
 		return prop
 	}
 	prop := new(StructProperties)
 	// in case of recursive protos, fill this in now.
 	propertiesMap[t] = prop
 	// build properties
 	prop.Prop = make([]*Properties, t.NumField())
 	prop.order = make([]int, t.NumField())
 	for i := 0; i < t.NumField(); i++ {
 		f := t.Field(i)
 		p := new(Properties)
 		name := f.Name
 		p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
 		oneof := f.Tag.Get("protobuf_oneof") // special case
 		if oneof != "" {
 			// Oneof fields don't use the traditional protobuf tag.
 			p.OrigName = oneof
 		}
 		prop.Prop[i] = p
 		prop.order[i] = i
 		if debug {
 			print(i, " ", f.Name, " ", t.String(), " ")
 			if p.Tag > 0 {
 				print(p.String())
 			}
 			print("\n")
 		}
 	}
 	// Re-order prop.order.
 	sort.Sort(prop)
 	type oneofMessage interface {
 		XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
 	}
 	if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {
 		var oots []interface{}
 		_, _, _, oots = om.XXX_OneofFuncs()
 		// Interpret oneof metadata.
 		prop.OneofTypes = make(map[string]*OneofProperties)
 		for _, oot := range oots {
 			oop := &OneofProperties{
 				Type: reflect.ValueOf(oot).Type(), // *T
 				Prop: new(Properties),
 			}
 			sft := oop.Type.Elem().Field(0)
 			oop.Prop.Name = sft.Name
 			oop.Prop.Parse(sft.Tag.Get("protobuf"))
 			// There will be exactly one interface field that
 			// this new value is assignable to.
 			for i := 0; i < t.NumField(); i++ {
 				f := t.Field(i)
 				if f.Type.Kind() != reflect.Interface {
 					continue
 				}
 				if !oop.Type.AssignableTo(f.Type) {
 					continue
 				}
 				oop.Field = i
 				break
 			}
 			prop.OneofTypes[oop.Prop.OrigName] = oop
 		}
 	}
 	// build required counts
 	// build tags
 	reqCount := 0
 	prop.decoderOrigNames = make(map[string]int)
 	for i, p := range prop.Prop {
 		if strings.HasPrefix(p.Name, "XXX_") {
 			// Internal fields should not appear in tags/origNames maps.
 			// They are handled specially when encoding and decoding.
 			continue
 		}
 		if p.Required {
 			reqCount++
 		}
 		prop.decoderTags.put(p.Tag, i)
 		prop.decoderOrigNames[p.OrigName] = i
 	}
 	prop.reqCount = reqCount
 	return prop
 }
 // A global registry of enum types.
 // The generated code will register the generated maps by calling RegisterEnum.
 var enumValueMaps = make(map[string]map[string]int32)
 // RegisterEnum is called from the generated code to install the enum descriptor
 // maps into the global table to aid parsing text format protocol buffers.
 func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
 	if _, ok := enumValueMaps[typeName]; ok {
 		panic("proto: duplicate enum registered: " + typeName)
 	}
 	enumValueMaps[typeName] = valueMap
 }
 // EnumValueMap returns the mapping from names to integers of the
 // enum type enumType, or a nil if not found.
 func EnumValueMap(enumType string) map[string]int32 {
 	return enumValueMaps[enumType]
 }
 // A registry of all linked message types.
 // The string is a fully-qualified proto name ("pkg.Message").
 var (
 	protoTypedNils = make(map[string]Message)      // a map from proto names to typed nil pointers
 	protoMapTypes  = make(map[string]reflect.Type) // a map from proto names to map types
 	revProtoTypes  = make(map[reflect.Type]string)
 )
 // RegisterType is called from generated code and maps from the fully qualified
 // proto name to the type (pointer to struct) of the protocol buffer.
 func RegisterType(x Message, name string) {
 	if _, ok := protoTypedNils[name]; ok {
 		// TODO: Some day, make this a panic.
 		log.Printf("proto: duplicate proto type registered: %s", name)
 		return
 	}
 	t := reflect.TypeOf(x)
 	if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {
 		// Generated code always calls RegisterType with nil x.
 		// This check is just for extra safety.
 		protoTypedNils[name] = x
 	} else {
 		protoTypedNils[name] = reflect.Zero(t).Interface().(Message)
 	}
 	revProtoTypes[t] = name
 }
 // RegisterMapType is called from generated code and maps from the fully qualified
 // proto name to the native map type of the proto map definition.
 func RegisterMapType(x interface{}, name string) {
 	if reflect.TypeOf(x).Kind() != reflect.Map {
 		panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))
 	}
 	if _, ok := protoMapTypes[name]; ok {
 		log.Printf("proto: duplicate proto type registered: %s", name)
 		return
 	}
 	t := reflect.TypeOf(x)
 	protoMapTypes[name] = t
 	revProtoTypes[t] = name
 }
 // MessageName returns the fully-qualified proto name for the given message type.
 func MessageName(x Message) string {
 	type xname interface {
 		XXX_MessageName() string
 	}
 	if m, ok := x.(xname); ok {
 		return m.XXX_MessageName()
 	}
 	return revProtoTypes[reflect.TypeOf(x)]
 }
 // MessageType returns the message type (pointer to struct) for a named message.
 // The type is not guaranteed to implement proto.Message if the name refers to a
 // map entry.
 func MessageType(name string) reflect.Type {
 	if t, ok := protoTypedNils[name]; ok {
 		return reflect.TypeOf(t)
 	}
 	return protoMapTypes[name]
 }
 // A registry of all linked proto files.
 var (
 	protoFiles = make(map[string][]byte) // file name => fileDescriptor
 )
 // RegisterFile is called from generated code and maps from the
 // full file name of a .proto file to its compressed FileDescriptorProto.
 func RegisterFile(filename string, fileDescriptor []byte) {
 	protoFiles[filename] = fileDescriptor
 }
 // FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
 func FileDescriptor(filename string) []byte { return protoFiles[filename] }
--- a/vendor/github.com/golang/protobuf/proto/table_marshal.go
+++ b/vendor/github.com/golang/protobuf/proto/table_marshal.go
--- a/vendor/github.com/golang/protobuf/proto/table_merge.go
+++ b/vendor/github.com/golang/protobuf/proto/table_merge.go
@@ -0,0 +1,654 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2016 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 import (
 	"fmt"
 	"reflect"
 	"strings"
 	"sync"
 	"sync/atomic"
 )
 // Merge merges the src message into dst.
 // This assumes that dst and src of the same type and are non-nil.
 func (a *InternalMessageInfo) Merge(dst, src Message) {
 	mi := atomicLoadMergeInfo(&a.merge)
 	if mi == nil {
 		mi = getMergeInfo(reflect.TypeOf(dst).Elem())
 		atomicStoreMergeInfo(&a.merge, mi)
 	}
 	mi.merge(toPointer(&dst), toPointer(&src))
 }
 type mergeInfo struct {
 	typ reflect.Type
 	initialized int32 // 0: only typ is valid, 1: everything is valid
 	lock        sync.Mutex
 	fields       []mergeFieldInfo
 	unrecognized field // Offset of XXX_unrecognized
 }
 type mergeFieldInfo struct {
 	field field // Offset of field, guaranteed to be valid
 	// isPointer reports whether the value in the field is a pointer.
 	// This is true for the following situations:
 	//	* Pointer to struct
 	//	* Pointer to basic type (proto2 only)
 	//	* Slice (first value in slice header is a pointer)
 	//	* String (first value in string header is a pointer)
 	isPointer bool
 	// basicWidth reports the width of the field assuming that it is directly
 	// embedded in the struct (as is the case for basic types in proto3).
 	// The possible values are:
 	// 	0: invalid
 	//	1: bool
 	//	4: int32, uint32, float32
 	//	8: int64, uint64, float64
 	basicWidth int
 	// Where dst and src are pointers to the types being merged.
 	merge func(dst, src pointer)
 }
 var (
 	mergeInfoMap  = map[reflect.Type]*mergeInfo{}
 	mergeInfoLock sync.Mutex
 )
 func getMergeInfo(t reflect.Type) *mergeInfo {
 	mergeInfoLock.Lock()
 	defer mergeInfoLock.Unlock()
 	mi := mergeInfoMap[t]
 	if mi == nil {
 		mi = &mergeInfo{typ: t}
 		mergeInfoMap[t] = mi
 	}
 	return mi
 }
 // merge merges src into dst assuming they are both of type *mi.typ.
 func (mi *mergeInfo) merge(dst, src pointer) {
 	if dst.isNil() {
 		panic("proto: nil destination")
 	}
 	if src.isNil() {
 		return // Nothing to do.
 	}
 	if atomic.LoadInt32(&mi.initialized) == 0 {
 		mi.computeMergeInfo()
 	}
 	for _, fi := range mi.fields {
 		sfp := src.offset(fi.field)
 		// As an optimization, we can avoid the merge function call cost
 		// if we know for sure that the source will have no effect
 		// by checking if it is the zero value.
 		if unsafeAllowed {
 			if fi.isPointer && sfp.getPointer().isNil() { // Could be slice or string
 				continue
 			}
 			if fi.basicWidth > 0 {
 				switch {
 				case fi.basicWidth == 1 && !*sfp.toBool():
 					continue
 				case fi.basicWidth == 4 && *sfp.toUint32() == 0:
 					continue
 				case fi.basicWidth == 8 && *sfp.toUint64() == 0:
 					continue
 				}
 			}
 		}
 		dfp := dst.offset(fi.field)
 		fi.merge(dfp, sfp)
 	}
 	// TODO: Make this faster?
 	out := dst.asPointerTo(mi.typ).Elem()
 	in := src.asPointerTo(mi.typ).Elem()
 	if emIn, err := extendable(in.Addr().Interface()); err == nil {
 		emOut, _ := extendable(out.Addr().Interface())
 		mIn, muIn := emIn.extensionsRead()
 		if mIn != nil {
 			mOut := emOut.extensionsWrite()
 			muIn.Lock()
 			mergeExtension(mOut, mIn)
 			muIn.Unlock()
 		}
 	}
 	if mi.unrecognized.IsValid() {
 		if b := *src.offset(mi.unrecognized).toBytes(); len(b) > 0 {
 			*dst.offset(mi.unrecognized).toBytes() = append([]byte(nil), b...)
 		}
 	}
 }
 func (mi *mergeInfo) computeMergeInfo() {
 	mi.lock.Lock()
 	defer mi.lock.Unlock()
 	if mi.initialized != 0 {
 		return
 	}
 	t := mi.typ
 	n := t.NumField()
 	props := GetProperties(t)
 	for i := 0; i < n; i++ {
 		f := t.Field(i)
 		if strings.HasPrefix(f.Name, "XXX_") {
 			continue
 		}
 		mfi := mergeFieldInfo{field: toField(&f)}
 		tf := f.Type
 		// As an optimization, we can avoid the merge function call cost
 		// if we know for sure that the source will have no effect
 		// by checking if it is the zero value.
 		if unsafeAllowed {
 			switch tf.Kind() {
 			case reflect.Ptr, reflect.Slice, reflect.String:
 				// As a special case, we assume slices and strings are pointers
 				// since we know that the first field in the SliceSlice or
 				// StringHeader is a data pointer.
 				mfi.isPointer = true
 			case reflect.Bool:
 				mfi.basicWidth = 1
 			case reflect.Int32, reflect.Uint32, reflect.Float32:
 				mfi.basicWidth = 4
 			case reflect.Int64, reflect.Uint64, reflect.Float64:
 				mfi.basicWidth = 8
 			}
 		}
 		// Unwrap tf to get at its most basic type.
 		var isPointer, isSlice bool
 		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
 			isSlice = true
 			tf = tf.Elem()
 		}
 		if tf.Kind() == reflect.Ptr {
 			isPointer = true
 			tf = tf.Elem()
 		}
 		if isPointer && isSlice && tf.Kind() != reflect.Struct {
 			panic("both pointer and slice for basic type in " + tf.Name())
 		}
 		switch tf.Kind() {
 		case reflect.Int32:
 			switch {
 			case isSlice: // E.g., []int32
 				mfi.merge = func(dst, src pointer) {
 					// NOTE: toInt32Slice is not defined (see pointer_reflect.go).
 					/*
 						sfsp := src.toInt32Slice()
 						if *sfsp != nil {
 							dfsp := dst.toInt32Slice()
 							*dfsp = append(*dfsp, *sfsp...)
 							if *dfsp == nil {
 								*dfsp = []int64{}
 							}
 						}
 					*/
 					sfs := src.getInt32Slice()
 					if sfs != nil {
 						dfs := dst.getInt32Slice()
 						dfs = append(dfs, sfs...)
 						if dfs == nil {
 							dfs = []int32{}
 						}
 						dst.setInt32Slice(dfs)
 					}
 				}
 			case isPointer: // E.g., *int32
 				mfi.merge = func(dst, src pointer) {
 					// NOTE: toInt32Ptr is not defined (see pointer_reflect.go).
 					/*
 						sfpp := src.toInt32Ptr()
 						if *sfpp != nil {
 							dfpp := dst.toInt32Ptr()
 							if *dfpp == nil {
 								*dfpp = Int32(**sfpp)
 							} else {
 								**dfpp = **sfpp
 							}
 						}
 					*/
 					sfp := src.getInt32Ptr()
 					if sfp != nil {
 						dfp := dst.getInt32Ptr()
 						if dfp == nil {
 							dst.setInt32Ptr(*sfp)
 						} else {
 							*dfp = *sfp
 						}
 					}
 				}
 			default: // E.g., int32
 				mfi.merge = func(dst, src pointer) {
 					if v := *src.toInt32(); v != 0 {
 						*dst.toInt32() = v
 					}
 				}
 			}
 		case reflect.Int64:
 			switch {
 			case isSlice: // E.g., []int64
 				mfi.merge = func(dst, src pointer) {
 					sfsp := src.toInt64Slice()
 					if *sfsp != nil {
 						dfsp := dst.toInt64Slice()
 						*dfsp = append(*dfsp, *sfsp...)
 						if *dfsp == nil {
 							*dfsp = []int64{}
 						}
 					}
 				}
 			case isPointer: // E.g., *int64
 				mfi.merge = func(dst, src pointer) {
 					sfpp := src.toInt64Ptr()
 					if *sfpp != nil {
 						dfpp := dst.toInt64Ptr()
 						if *dfpp == nil {
 							*dfpp = Int64(**sfpp)
 						} else {
 							**dfpp = **sfpp
 						}
 					}
 				}
 			default: // E.g., int64
 				mfi.merge = func(dst, src pointer) {
 					if v := *src.toInt64(); v != 0 {
 						*dst.toInt64() = v
 					}
 				}
 			}
 		case reflect.Uint32:
 			switch {
 			case isSlice: // E.g., []uint32
 				mfi.merge = func(dst, src pointer) {
 					sfsp := src.toUint32Slice()
 					if *sfsp != nil {
 						dfsp := dst.toUint32Slice()
 						*dfsp = append(*dfsp, *sfsp...)
 						if *dfsp == nil {
 							*dfsp = []uint32{}
 						}
 					}
 				}
 			case isPointer: // E.g., *uint32
 				mfi.merge = func(dst, src pointer) {
 					sfpp := src.toUint32Ptr()
 					if *sfpp != nil {
 						dfpp := dst.toUint32Ptr()
 						if *dfpp == nil {
 							*dfpp = Uint32(**sfpp)
 						} else {
 							**dfpp = **sfpp
 						}
 					}
 				}
 			default: // E.g., uint32
 				mfi.merge = func(dst, src pointer) {
 					if v := *src.toUint32(); v != 0 {
 						*dst.toUint32() = v
 					}
 				}
 			}
 		case reflect.Uint64:
 			switch {
 			case isSlice: // E.g., []uint64
 				mfi.merge = func(dst, src pointer) {
 					sfsp := src.toUint64Slice()
 					if *sfsp != nil {
 						dfsp := dst.toUint64Slice()
 						*dfsp = append(*dfsp, *sfsp...)
 						if *dfsp == nil {
 							*dfsp = []uint64{}
 						}
 					}
 				}
 			case isPointer: // E.g., *uint64
 				mfi.merge = func(dst, src pointer) {
 					sfpp := src.toUint64Ptr()
 					if *sfpp != nil {
 						dfpp := dst.toUint64Ptr()
 						if *dfpp == nil {
 							*dfpp = Uint64(**sfpp)
 						} else {
 							**dfpp = **sfpp
 						}
 					}
 				}
 			default: // E.g., uint64
 				mfi.merge = func(dst, src pointer) {
 					if v := *src.toUint64(); v != 0 {
 						*dst.toUint64() = v
 					}
 				}
 			}
 		case reflect.Float32:
 			switch {
 			case isSlice: // E.g., []float32
 				mfi.merge = func(dst, src pointer) {
 					sfsp := src.toFloat32Slice()
 					if *sfsp != nil {
 						dfsp := dst.toFloat32Slice()
 						*dfsp = append(*dfsp, *sfsp...)
 						if *dfsp == nil {
 							*dfsp = []float32{}
 						}
 					}
 				}
 			case isPointer: // E.g., *float32
 				mfi.merge = func(dst, src pointer) {
 					sfpp := src.toFloat32Ptr()
 					if *sfpp != nil {
 						dfpp := dst.toFloat32Ptr()
 						if *dfpp == nil {
 							*dfpp = Float32(**sfpp)
 						} else {
 							**dfpp = **sfpp
 						}
 					}
 				}
 			default: // E.g., float32
 				mfi.merge = func(dst, src pointer) {
 					if v := *src.toFloat32(); v != 0 {
 						*dst.toFloat32() = v
 					}
 				}
 			}
 		case reflect.Float64:
 			switch {
 			case isSlice: // E.g., []float64
 				mfi.merge = func(dst, src pointer) {
 					sfsp := src.toFloat64Slice()
 					if *sfsp != nil {
 						dfsp := dst.toFloat64Slice()
 						*dfsp = append(*dfsp, *sfsp...)
 						if *dfsp == nil {
 							*dfsp = []float64{}
 						}
 					}
 				}
 			case isPointer: // E.g., *float64
 				mfi.merge = func(dst, src pointer) {
 					sfpp := src.toFloat64Ptr()
 					if *sfpp != nil {
 						dfpp := dst.toFloat64Ptr()
 						if *dfpp == nil {
 							*dfpp = Float64(**sfpp)
 						} else {
 							**dfpp = **sfpp
 						}
 					}
 				}
 			default: // E.g., float64
 				mfi.merge = func(dst, src pointer) {
 					if v := *src.toFloat64(); v != 0 {
 						*dst.toFloat64() = v
 					}
 				}
 			}
 		case reflect.Bool:
 			switch {
 			case isSlice: // E.g., []bool
 				mfi.merge = func(dst, src pointer) {
 					sfsp := src.toBoolSlice()
 					if *sfsp != nil {
 						dfsp := dst.toBoolSlice()
 						*dfsp = append(*dfsp, *sfsp...)
 						if *dfsp == nil {
 							*dfsp = []bool{}
 						}
 					}
 				}
 			case isPointer: // E.g., *bool
 				mfi.merge = func(dst, src pointer) {
 					sfpp := src.toBoolPtr()
 					if *sfpp != nil {
 						dfpp := dst.toBoolPtr()
 						if *dfpp == nil {
 							*dfpp = Bool(**sfpp)
 						} else {
 							**dfpp = **sfpp
 						}
 					}
 				}
 			default: // E.g., bool
 				mfi.merge = func(dst, src pointer) {
 					if v := *src.toBool(); v {
 						*dst.toBool() = v
 					}
 				}
 			}
 		case reflect.String:
 			switch {
 			case isSlice: // E.g., []string
 				mfi.merge = func(dst, src pointer) {
 					sfsp := src.toStringSlice()
 					if *sfsp != nil {
 						dfsp := dst.toStringSlice()
 						*dfsp = append(*dfsp, *sfsp...)
 						if *dfsp == nil {
 							*dfsp = []string{}
 						}
 					}
 				}
 			case isPointer: // E.g., *string
 				mfi.merge = func(dst, src pointer) {
 					sfpp := src.toStringPtr()
 					if *sfpp != nil {
 						dfpp := dst.toStringPtr()
 						if *dfpp == nil {
 							*dfpp = String(**sfpp)
 						} else {
 							**dfpp = **sfpp
 						}
 					}
 				}
 			default: // E.g., string
 				mfi.merge = func(dst, src pointer) {
 					if v := *src.toString(); v != "" {
 						*dst.toString() = v
 					}
 				}
 			}
 		case reflect.Slice:
 			isProto3 := props.Prop[i].proto3
 			switch {
 			case isPointer:
 				panic("bad pointer in byte slice case in " + tf.Name())
 			case tf.Elem().Kind() != reflect.Uint8:
 				panic("bad element kind in byte slice case in " + tf.Name())
 			case isSlice: // E.g., [][]byte
 				mfi.merge = func(dst, src pointer) {
 					sbsp := src.toBytesSlice()
 					if *sbsp != nil {
 						dbsp := dst.toBytesSlice()
 						for _, sb := range *sbsp {
 							if sb == nil {
 								*dbsp = append(*dbsp, nil)
 							} else {
 								*dbsp = append(*dbsp, append([]byte{}, sb...))
 							}
 						}
 						if *dbsp == nil {
 							*dbsp = [][]byte{}
 						}
 					}
 				}
 			default: // E.g., []byte
 				mfi.merge = func(dst, src pointer) {
 					sbp := src.toBytes()
 					if *sbp != nil {
 						dbp := dst.toBytes()
 						if !isProto3 || len(*sbp) > 0 {
 							*dbp = append([]byte{}, *sbp...)
 						}
 					}
 				}
 			}
 		case reflect.Struct:
 			switch {
 			case !isPointer:
 				panic(fmt.Sprintf("message field %s without pointer", tf))
 			case isSlice: // E.g., []*pb.T
 				mi := getMergeInfo(tf)
 				mfi.merge = func(dst, src pointer) {
 					sps := src.getPointerSlice()
 					if sps != nil {
 						dps := dst.getPointerSlice()
 						for _, sp := range sps {
 							var dp pointer
 							if !sp.isNil() {
 								dp = valToPointer(reflect.New(tf))
 								mi.merge(dp, sp)
 							}
 							dps = append(dps, dp)
 						}
 						if dps == nil {
 							dps = []pointer{}
 						}
 						dst.setPointerSlice(dps)
 					}
 				}
 			default: // E.g., *pb.T
 				mi := getMergeInfo(tf)
 				mfi.merge = func(dst, src pointer) {
 					sp := src.getPointer()
 					if !sp.isNil() {
 						dp := dst.getPointer()
 						if dp.isNil() {
 							dp = valToPointer(reflect.New(tf))
 							dst.setPointer(dp)
 						}
 						mi.merge(dp, sp)
 					}
 				}
 			}
 		case reflect.Map:
 			switch {
 			case isPointer || isSlice:
 				panic("bad pointer or slice in map case in " + tf.Name())
 			default: // E.g., map[K]V
 				mfi.merge = func(dst, src pointer) {
 					sm := src.asPointerTo(tf).Elem()
 					if sm.Len() == 0 {
 						return
 					}
 					dm := dst.asPointerTo(tf).Elem()
 					if dm.IsNil() {
 						dm.Set(reflect.MakeMap(tf))
 					}
 					switch tf.Elem().Kind() {
 					case reflect.Ptr: // Proto struct (e.g., *T)
 						for _, key := range sm.MapKeys() {
 							val := sm.MapIndex(key)
 							val = reflect.ValueOf(Clone(val.Interface().(Message)))
 							dm.SetMapIndex(key, val)
 						}
 					case reflect.Slice: // E.g. Bytes type (e.g., []byte)
 						for _, key := range sm.MapKeys() {
 							val := sm.MapIndex(key)
 							val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
 							dm.SetMapIndex(key, val)
 						}
 					default: // Basic type (e.g., string)
 						for _, key := range sm.MapKeys() {
 							val := sm.MapIndex(key)
 							dm.SetMapIndex(key, val)
 						}
 					}
 				}
 			}
 		case reflect.Interface:
 			// Must be oneof field.
 			switch {
 			case isPointer || isSlice:
 				panic("bad pointer or slice in interface case in " + tf.Name())
 			default: // E.g., interface{}
 				// TODO: Make this faster?
 				mfi.merge = func(dst, src pointer) {
 					su := src.asPointerTo(tf).Elem()
 					if !su.IsNil() {
 						du := dst.asPointerTo(tf).Elem()
 						typ := su.Elem().Type()
 						if du.IsNil() || du.Elem().Type() != typ {
 							du.Set(reflect.New(typ.Elem())) // Initialize interface if empty
 						}
 						sv := su.Elem().Elem().Field(0)
 						if sv.Kind() == reflect.Ptr && sv.IsNil() {
 							return
 						}
 						dv := du.Elem().Elem().Field(0)
 						if dv.Kind() == reflect.Ptr && dv.IsNil() {
 							dv.Set(reflect.New(sv.Type().Elem())) // Initialize proto message if empty
 						}
 						switch sv.Type().Kind() {
 						case reflect.Ptr: // Proto struct (e.g., *T)
 							Merge(dv.Interface().(Message), sv.Interface().(Message))
 						case reflect.Slice: // E.g. Bytes type (e.g., []byte)
 							dv.Set(reflect.ValueOf(append([]byte{}, sv.Bytes()...)))
 						default: // Basic type (e.g., string)
 							dv.Set(sv)
 						}
 					}
 				}
 			}
 		default:
 			panic(fmt.Sprintf("merger not found for type:%s", tf))
 		}
 		mi.fields = append(mi.fields, mfi)
 	}
 	mi.unrecognized = invalidField
 	if f, ok := t.FieldByName("XXX_unrecognized"); ok {
 		if f.Type != reflect.TypeOf([]byte{}) {
 			panic("expected XXX_unrecognized to be of type []byte")
 		}
 		mi.unrecognized = toField(&f)
 	}
 	atomic.StoreInt32(&mi.initialized, 1)
 }
--- a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
+++ b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
--- a/vendor/github.com/golang/protobuf/proto/text.go
+++ b/vendor/github.com/golang/protobuf/proto/text.go
@@ -0,0 +1,843 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2010 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 // Functions for writing the text protocol buffer format.
 import (
 	"bufio"
 	"bytes"
 	"encoding"
 	"errors"
 	"fmt"
 	"io"
 	"log"
 	"math"
 	"reflect"
 	"sort"
 	"strings"
 )
 var (
 	newline         = []byte("\n")
 	spaces          = []byte("                                        ")
 	endBraceNewline = []byte("}\n")
 	backslashN      = []byte{'\\', 'n'}
 	backslashR      = []byte{'\\', 'r'}
 	backslashT      = []byte{'\\', 't'}
 	backslashDQ     = []byte{'\\', '"'}
 	backslashBS     = []byte{'\\', '\\'}
 	posInf          = []byte("inf")
 	negInf          = []byte("-inf")
 	nan             = []byte("nan")
 )
 type writer interface {
 	io.Writer
 	WriteByte(byte) error
 }
 // textWriter is an io.Writer that tracks its indentation level.
 type textWriter struct {
 	ind      int
 	complete bool // if the current position is a complete line
 	compact  bool // whether to write out as a one-liner
 	w        writer
 }
 func (w *textWriter) WriteString(s string) (n int, err error) {
 	if !strings.Contains(s, "\n") {
 		if !w.compact && w.complete {
 			w.writeIndent()
 		}
 		w.complete = false
 		return io.WriteString(w.w, s)
 	}
 	// WriteString is typically called without newlines, so this
 	// codepath and its copy are rare.  We copy to avoid
 	// duplicating all of Write's logic here.
 	return w.Write([]byte(s))
 }
 func (w *textWriter) Write(p []byte) (n int, err error) {
 	newlines := bytes.Count(p, newline)
 	if newlines == 0 {
 		if !w.compact && w.complete {
 			w.writeIndent()
 		}
 		n, err = w.w.Write(p)
 		w.complete = false
 		return n, err
 	}
 	frags := bytes.SplitN(p, newline, newlines+1)
 	if w.compact {
 		for i, frag := range frags {
 			if i > 0 {
 				if err := w.w.WriteByte(' '); err != nil {
 					return n, err
 				}
 				n++
 			}
 			nn, err := w.w.Write(frag)
 			n += nn
 			if err != nil {
 				return n, err
 			}
 		}
 		return n, nil
 	}
 	for i, frag := range frags {
 		if w.complete {
 			w.writeIndent()
 		}
 		nn, err := w.w.Write(frag)
 		n += nn
 		if err != nil {
 			return n, err
 		}
 		if i+1 < len(frags) {
 			if err := w.w.WriteByte('\n'); err != nil {
 				return n, err
 			}
 			n++
 		}
 	}
 	w.complete = len(frags[len(frags)-1]) == 0
 	return n, nil
 }
 func (w *textWriter) WriteByte(c byte) error {
 	if w.compact && c == '\n' {
 		c = ' '
 	}
 	if !w.compact && w.complete {
 		w.writeIndent()
 	}
 	err := w.w.WriteByte(c)
 	w.complete = c == '\n'
 	return err
 }
 func (w *textWriter) indent() { w.ind++ }
 func (w *textWriter) unindent() {
 	if w.ind == 0 {
 		log.Print("proto: textWriter unindented too far")
 		return
 	}
 	w.ind--
 }
 func writeName(w *textWriter, props *Properties) error {
 	if _, err := w.WriteString(props.OrigName); err != nil {
 		return err
 	}
 	if props.Wire != "group" {
 		return w.WriteByte(':')
 	}
 	return nil
 }
 func requiresQuotes(u string) bool {
 	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
 	for _, ch := range u {
 		switch {
 		case ch == '.' || ch == '/' || ch == '_':
 			continue
 		case '0' <= ch && ch <= '9':
 			continue
 		case 'A' <= ch && ch <= 'Z':
 			continue
 		case 'a' <= ch && ch <= 'z':
 			continue
 		default:
 			return true
 		}
 	}
 	return false
 }
 // isAny reports whether sv is a google.protobuf.Any message
 func isAny(sv reflect.Value) bool {
 	type wkt interface {
 		XXX_WellKnownType() string
 	}
 	t, ok := sv.Addr().Interface().(wkt)
 	return ok && t.XXX_WellKnownType() == "Any"
 }
 // writeProto3Any writes an expanded google.protobuf.Any message.
 //
 // It returns (false, nil) if sv value can't be unmarshaled (e.g. because
 // required messages are not linked in).
 //
 // It returns (true, error) when sv was written in expanded format or an error
 // was encountered.
 func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
 	turl := sv.FieldByName("TypeUrl")
 	val := sv.FieldByName("Value")
 	if !turl.IsValid() || !val.IsValid() {
 		return true, errors.New("proto: invalid google.protobuf.Any message")
 	}
 	b, ok := val.Interface().([]byte)
 	if !ok {
 		return true, errors.New("proto: invalid google.protobuf.Any message")
 	}
 	parts := strings.Split(turl.String(), "/")
 	mt := MessageType(parts[len(parts)-1])
 	if mt == nil {
 		return false, nil
 	}
 	m := reflect.New(mt.Elem())
 	if err := Unmarshal(b, m.Interface().(Message)); err != nil {
 		return false, nil
 	}
 	w.Write([]byte("["))
 	u := turl.String()
 	if requiresQuotes(u) {
 		writeString(w, u)
 	} else {
 		w.Write([]byte(u))
 	}
 	if w.compact {
 		w.Write([]byte("]:<"))
 	} else {
 		w.Write([]byte("]: <\n"))
 		w.ind++
 	}
 	if err := tm.writeStruct(w, m.Elem()); err != nil {
 		return true, err
 	}
 	if w.compact {
 		w.Write([]byte("> "))
 	} else {
 		w.ind--
 		w.Write([]byte(">\n"))
 	}
 	return true, nil
 }
 func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
 	if tm.ExpandAny && isAny(sv) {
 		if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
 			return err
 		}
 	}
 	st := sv.Type()
 	sprops := GetProperties(st)
 	for i := 0; i < sv.NumField(); i++ {
 		fv := sv.Field(i)
 		props := sprops.Prop[i]
 		name := st.Field(i).Name
 		if name == "XXX_NoUnkeyedLiteral" {
 			continue
 		}
 		if strings.HasPrefix(name, "XXX_") {
 			// There are two XXX_ fields:
 			//   XXX_unrecognized []byte
 			//   XXX_extensions   map[int32]proto.Extension
 			// The first is handled here;
 			// the second is handled at the bottom of this function.
 			if name == "XXX_unrecognized" && !fv.IsNil() {
 				if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
 					return err
 				}
 			}
 			continue
 		}
 		if fv.Kind() == reflect.Ptr && fv.IsNil() {
 			// Field not filled in. This could be an optional field or
 			// a required field that wasn't filled in. Either way, there
 			// isn't anything we can show for it.
 			continue
 		}
 		if fv.Kind() == reflect.Slice && fv.IsNil() {
 			// Repeated field that is empty, or a bytes field that is unused.
 			continue
 		}
 		if props.Repeated && fv.Kind() == reflect.Slice {
 			// Repeated field.
 			for j := 0; j < fv.Len(); j++ {
 				if err := writeName(w, props); err != nil {
 					return err
 				}
 				if !w.compact {
 					if err := w.WriteByte(' '); err != nil {
 						return err
 					}
 				}
 				v := fv.Index(j)
 				if v.Kind() == reflect.Ptr && v.IsNil() {
 					// A nil message in a repeated field is not valid,
 					// but we can handle that more gracefully than panicking.
 					if _, err := w.Write([]byte("<nil>\n")); err != nil {
 						return err
 					}
 					continue
 				}
 				if err := tm.writeAny(w, v, props); err != nil {
 					return err
 				}
 				if err := w.WriteByte('\n'); err != nil {
 					return err
 				}
 			}
 			continue
 		}
 		if fv.Kind() == reflect.Map {
 			// Map fields are rendered as a repeated struct with key/value fields.
 			keys := fv.MapKeys()
 			sort.Sort(mapKeys(keys))
 			for _, key := range keys {
 				val := fv.MapIndex(key)
 				if err := writeName(w, props); err != nil {
 					return err
 				}
 				if !w.compact {
 					if err := w.WriteByte(' '); err != nil {
 						return err
 					}
 				}
 				// open struct
 				if err := w.WriteByte('<'); err != nil {
 					return err
 				}
 				if !w.compact {
 					if err := w.WriteByte('\n'); err != nil {
 						return err
 					}
 				}
 				w.indent()
 				// key
 				if _, err := w.WriteString("key:"); err != nil {
 					return err
 				}
 				if !w.compact {
 					if err := w.WriteByte(' '); err != nil {
 						return err
 					}
 				}
 				if err := tm.writeAny(w, key, props.MapKeyProp); err != nil {
 					return err
 				}
 				if err := w.WriteByte('\n'); err != nil {
 					return err
 				}
 				// nil values aren't legal, but we can avoid panicking because of them.
 				if val.Kind() != reflect.Ptr || !val.IsNil() {
 					// value
 					if _, err := w.WriteString("value:"); err != nil {
 						return err
 					}
 					if !w.compact {
 						if err := w.WriteByte(' '); err != nil {
 							return err
 						}
 					}
 					if err := tm.writeAny(w, val, props.MapValProp); err != nil {
 						return err
 					}
 					if err := w.WriteByte('\n'); err != nil {
 						return err
 					}
 				}
 				// close struct
 				w.unindent()
 				if err := w.WriteByte('>'); err != nil {
 					return err
 				}
 				if err := w.WriteByte('\n'); err != nil {
 					return err
 				}
 			}
 			continue
 		}
 		if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
 			// empty bytes field
 			continue
 		}
 		if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
 			// proto3 non-repeated scalar field; skip if zero value
 			if isProto3Zero(fv) {
 				continue
 			}
 		}
 		if fv.Kind() == reflect.Interface {
 			// Check if it is a oneof.
 			if st.Field(i).Tag.Get("protobuf_oneof") != "" {
 				// fv is nil, or holds a pointer to generated struct.
 				// That generated struct has exactly one field,
 				// which has a protobuf struct tag.
 				if fv.IsNil() {
 					continue
 				}
 				inner := fv.Elem().Elem() // interface -> *T -> T
 				tag := inner.Type().Field(0).Tag.Get("protobuf")
 				props = new(Properties) // Overwrite the outer props var, but not its pointee.
 				props.Parse(tag)
 				// Write the value in the oneof, not the oneof itself.
 				fv = inner.Field(0)
 				// Special case to cope with malformed messages gracefully:
 				// If the value in the oneof is a nil pointer, don't panic
 				// in writeAny.
 				if fv.Kind() == reflect.Ptr && fv.IsNil() {
 					// Use errors.New so writeAny won't render quotes.
 					msg := errors.New("/* nil */")
 					fv = reflect.ValueOf(&msg).Elem()
 				}
 			}
 		}
 		if err := writeName(w, props); err != nil {
 			return err
 		}
 		if !w.compact {
 			if err := w.WriteByte(' '); err != nil {
 				return err
 			}
 		}
 		// Enums have a String method, so writeAny will work fine.
 		if err := tm.writeAny(w, fv, props); err != nil {
 			return err
 		}
 		if err := w.WriteByte('\n'); err != nil {
 			return err
 		}
 	}
 	// Extensions (the XXX_extensions field).
 	pv := sv.Addr()
 	if _, err := extendable(pv.Interface()); err == nil {
 		if err := tm.writeExtensions(w, pv); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 // writeAny writes an arbitrary field.
 func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
 	v = reflect.Indirect(v)
 	// Floats have special cases.
 	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
 		x := v.Float()
 		var b []byte
 		switch {
 		case math.IsInf(x, 1):
 			b = posInf
 		case math.IsInf(x, -1):
 			b = negInf
 		case math.IsNaN(x):
 			b = nan
 		}
 		if b != nil {
 			_, err := w.Write(b)
 			return err
 		}
 		// Other values are handled below.
 	}
 	// We don't attempt to serialise every possible value type; only those
 	// that can occur in protocol buffers.
 	switch v.Kind() {
 	case reflect.Slice:
 		// Should only be a []byte; repeated fields are handled in writeStruct.
 		if err := writeString(w, string(v.Bytes())); err != nil {
 			return err
 		}
 	case reflect.String:
 		if err := writeString(w, v.String()); err != nil {
 			return err
 		}
 	case reflect.Struct:
 		// Required/optional group/message.
 		var bra, ket byte = '<', '>'
 		if props != nil && props.Wire == "group" {
 			bra, ket = '{', '}'
 		}
 		if err := w.WriteByte(bra); err != nil {
 			return err
 		}
 		if !w.compact {
 			if err := w.WriteByte('\n'); err != nil {
 				return err
 			}
 		}
 		w.indent()
 		if v.CanAddr() {
 			// Calling v.Interface on a struct causes the reflect package to
 			// copy the entire struct. This is racy with the new Marshaler
 			// since we atomically update the XXX_sizecache.
 			//
 			// Thus, we retrieve a pointer to the struct if possible to avoid
 			// a race since v.Interface on the pointer doesn't copy the struct.
 			//
 			// If v is not addressable, then we are not worried about a race
 			// since it implies that the binary Marshaler cannot possibly be
 			// mutating this value.
 			v = v.Addr()
 		}
 		if etm, ok := v.Interface().(encoding.TextMarshaler); ok {
 			text, err := etm.MarshalText()
 			if err != nil {
 				return err
 			}
 			if _, err = w.Write(text); err != nil {
 				return err
 			}
 		} else {
 			if v.Kind() == reflect.Ptr {
 				v = v.Elem()
 			}
 			if err := tm.writeStruct(w, v); err != nil {
 				return err
 			}
 		}
 		w.unindent()
 		if err := w.WriteByte(ket); err != nil {
 			return err
 		}
 	default:
 		_, err := fmt.Fprint(w, v.Interface())
 		return err
 	}
 	return nil
 }
 // equivalent to C's isprint.
 func isprint(c byte) bool {
 	return c >= 0x20 && c < 0x7f
 }
 // writeString writes a string in the protocol buffer text format.
 // It is similar to strconv.Quote except we don't use Go escape sequences,
 // we treat the string as a byte sequence, and we use octal escapes.
 // These differences are to maintain interoperability with the other
 // languages' implementations of the text format.
 func writeString(w *textWriter, s string) error {
 	// use WriteByte here to get any needed indent
 	if err := w.WriteByte('"'); err != nil {
 		return err
 	}
 	// Loop over the bytes, not the runes.
 	for i := 0; i < len(s); i++ {
 		var err error
 		// Divergence from C++: we don't escape apostrophes.
 		// There's no need to escape them, and the C++ parser
 		// copes with a naked apostrophe.
 		switch c := s[i]; c {
 		case '\n':
 			_, err = w.w.Write(backslashN)
 		case '\r':
 			_, err = w.w.Write(backslashR)
 		case '\t':
 			_, err = w.w.Write(backslashT)
 		case '"':
 			_, err = w.w.Write(backslashDQ)
 		case '\\':
 			_, err = w.w.Write(backslashBS)
 		default:
 			if isprint(c) {
 				err = w.w.WriteByte(c)
 			} else {
 				_, err = fmt.Fprintf(w.w, "\\%03o", c)
 			}
 		}
 		if err != nil {
 			return err
 		}
 	}
 	return w.WriteByte('"')
 }
 func writeUnknownStruct(w *textWriter, data []byte) (err error) {
 	if !w.compact {
 		if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
 			return err
 		}
 	}
 	b := NewBuffer(data)
 	for b.index < len(b.buf) {
 		x, err := b.DecodeVarint()
 		if err != nil {
 			_, err := fmt.Fprintf(w, "/* %v */\n", err)
 			return err
 		}
 		wire, tag := x&7, x>>3
 		if wire == WireEndGroup {
 			w.unindent()
 			if _, err := w.Write(endBraceNewline); err != nil {
 				return err
 			}
 			continue
 		}
 		if _, err := fmt.Fprint(w, tag); err != nil {
 			return err
 		}
 		if wire != WireStartGroup {
 			if err := w.WriteByte(':'); err != nil {
 				return err
 			}
 		}
 		if !w.compact || wire == WireStartGroup {
 			if err := w.WriteByte(' '); err != nil {
 				return err
 			}
 		}
 		switch wire {
 		case WireBytes:
 			buf, e := b.DecodeRawBytes(false)
 			if e == nil {
 				_, err = fmt.Fprintf(w, "%q", buf)
 			} else {
 				_, err = fmt.Fprintf(w, "/* %v */", e)
 			}
 		case WireFixed32:
 			x, err = b.DecodeFixed32()
 			err = writeUnknownInt(w, x, err)
 		case WireFixed64:
 			x, err = b.DecodeFixed64()
 			err = writeUnknownInt(w, x, err)
 		case WireStartGroup:
 			err = w.WriteByte('{')
 			w.indent()
 		case WireVarint:
 			x, err = b.DecodeVarint()
 			err = writeUnknownInt(w, x, err)
 		default:
 			_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
 		}
 		if err != nil {
 			return err
 		}
 		if err = w.WriteByte('\n'); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 func writeUnknownInt(w *textWriter, x uint64, err error) error {
 	if err == nil {
 		_, err = fmt.Fprint(w, x)
 	} else {
 		_, err = fmt.Fprintf(w, "/* %v */", err)
 	}
 	return err
 }
 type int32Slice []int32
 func (s int32Slice) Len() int           { return len(s) }
 func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
 func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 // writeExtensions writes all the extensions in pv.
 // pv is assumed to be a pointer to a protocol message struct that is extendable.
 func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
 	emap := extensionMaps[pv.Type().Elem()]
 	ep, _ := extendable(pv.Interface())
 	// Order the extensions by ID.
 	// This isn't strictly necessary, but it will give us
 	// canonical output, which will also make testing easier.
 	m, mu := ep.extensionsRead()
 	if m == nil {
 		return nil
 	}
 	mu.Lock()
 	ids := make([]int32, 0, len(m))
 	for id := range m {
 		ids = append(ids, id)
 	}
 	sort.Sort(int32Slice(ids))
 	mu.Unlock()
 	for _, extNum := range ids {
 		ext := m[extNum]
 		var desc *ExtensionDesc
 		if emap != nil {
 			desc = emap[extNum]
 		}
 		if desc == nil {
 			// Unknown extension.
 			if err := writeUnknownStruct(w, ext.enc); err != nil {
 				return err
 			}
 			continue
 		}
 		pb, err := GetExtension(ep, desc)
 		if err != nil {
 			return fmt.Errorf("failed getting extension: %v", err)
 		}
 		// Repeated extensions will appear as a slice.
 		if !desc.repeated() {
 			if err := tm.writeExtension(w, desc.Name, pb); err != nil {
 				return err
 			}
 		} else {
 			v := reflect.ValueOf(pb)
 			for i := 0; i < v.Len(); i++ {
 				if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
 					return err
 				}
 			}
 		}
 	}
 	return nil
 }
 func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
 	if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
 		return err
 	}
 	if !w.compact {
 		if err := w.WriteByte(' '); err != nil {
 			return err
 		}
 	}
 	if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
 		return err
 	}
 	if err := w.WriteByte('\n'); err != nil {
 		return err
 	}
 	return nil
 }
 func (w *textWriter) writeIndent() {
 	if !w.complete {
 		return
 	}
 	remain := w.ind * 2
 	for remain > 0 {
 		n := remain
 		if n > len(spaces) {
 			n = len(spaces)
 		}
 		w.w.Write(spaces[:n])
 		remain -= n
 	}
 	w.complete = false
 }
 // TextMarshaler is a configurable text format marshaler.
 type TextMarshaler struct {
 	Compact   bool // use compact text format (one line).
 	ExpandAny bool // expand google.protobuf.Any messages of known types
 }
 // Marshal writes a given protocol buffer in text format.
 // The only errors returned are from w.
 func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
 	val := reflect.ValueOf(pb)
 	if pb == nil || val.IsNil() {
 		w.Write([]byte("<nil>"))
 		return nil
 	}
 	var bw *bufio.Writer
 	ww, ok := w.(writer)
 	if !ok {
 		bw = bufio.NewWriter(w)
 		ww = bw
 	}
 	aw := &textWriter{
 		w:        ww,
 		complete: true,
 		compact:  tm.Compact,
 	}
 	if etm, ok := pb.(encoding.TextMarshaler); ok {
 		text, err := etm.MarshalText()
 		if err != nil {
 			return err
 		}
 		if _, err = aw.Write(text); err != nil {
 			return err
 		}
 		if bw != nil {
 			return bw.Flush()
 		}
 		return nil
 	}
 	// Dereference the received pointer so we don't have outer < and >.
 	v := reflect.Indirect(val)
 	if err := tm.writeStruct(aw, v); err != nil {
 		return err
 	}
 	if bw != nil {
 		return bw.Flush()
 	}
 	return nil
 }
 // Text is the same as Marshal, but returns the string directly.
 func (tm *TextMarshaler) Text(pb Message) string {
 	var buf bytes.Buffer
 	tm.Marshal(&buf, pb)
 	return buf.String()
 }
 var (
 	defaultTextMarshaler = TextMarshaler{}
 	compactTextMarshaler = TextMarshaler{Compact: true}
 )
 // TODO: consider removing some of the Marshal functions below.
 // MarshalText writes a given protocol buffer in text format.
 // The only errors returned are from w.
 func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
 // MarshalTextString is the same as MarshalText, but returns the string directly.
 func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
 // CompactText writes a given protocol buffer in compact text format (one line).
 func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
 // CompactTextString is the same as CompactText, but returns the string directly.
 func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }
--- a/vendor/github.com/golang/protobuf/proto/text_parser.go
+++ b/vendor/github.com/golang/protobuf/proto/text_parser.go
@@ -0,0 +1,880 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2010 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package proto
 // Functions for parsing the Text protocol buffer format.
 // TODO: message sets.
 import (
 	"encoding"
 	"errors"
 	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
 	"unicode/utf8"
 )
 // Error string emitted when deserializing Any and fields are already set
 const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
 type ParseError struct {
 	Message string
 	Line    int // 1-based line number
 	Offset  int // 0-based byte offset from start of input
 }
 func (p *ParseError) Error() string {
 	if p.Line == 1 {
 		// show offset only for first line
 		return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
 	}
 	return fmt.Sprintf("line %d: %v", p.Line, p.Message)
 }
 type token struct {
 	value    string
 	err      *ParseError
 	line     int    // line number
 	offset   int    // byte number from start of input, not start of line
 	unquoted string // the unquoted version of value, if it was a quoted string
 }
 func (t *token) String() string {
 	if t.err == nil {
 		return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
 	}
 	return fmt.Sprintf("parse error: %v", t.err)
 }
 type textParser struct {
 	s            string // remaining input
 	done         bool   // whether the parsing is finished (success or error)
 	backed       bool   // whether back() was called
 	offset, line int
 	cur          token
 }
 func newTextParser(s string) *textParser {
 	p := new(textParser)
 	p.s = s
 	p.line = 1
 	p.cur.line = 1
 	return p
 }
 func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
 	pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
 	p.cur.err = pe
 	p.done = true
 	return pe
 }
 // Numbers and identifiers are matched by [-+._A-Za-z0-9]
 func isIdentOrNumberChar(c byte) bool {
 	switch {
 	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
 		return true
 	case '0' <= c && c <= '9':
 		return true
 	}
 	switch c {
 	case '-', '+', '.', '_':
 		return true
 	}
 	return false
 }
 func isWhitespace(c byte) bool {
 	switch c {
 	case ' ', '\t', '\n', '\r':
 		return true
 	}
 	return false
 }
 func isQuote(c byte) bool {
 	switch c {
 	case '"', '\'':
 		return true
 	}
 	return false
 }
 func (p *textParser) skipWhitespace() {
 	i := 0
 	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
 		if p.s[i] == '#' {
 			// comment; skip to end of line or input
 			for i < len(p.s) && p.s[i] != '\n' {
 				i++
 			}
 			if i == len(p.s) {
 				break
 			}
 		}
 		if p.s[i] == '\n' {
 			p.line++
 		}
 		i++
 	}
 	p.offset += i
 	p.s = p.s[i:len(p.s)]
 	if len(p.s) == 0 {
 		p.done = true
 	}
 }
 func (p *textParser) advance() {
 	// Skip whitespace
 	p.skipWhitespace()
 	if p.done {
 		return
 	}
 	// Start of non-whitespace
 	p.cur.err = nil
 	p.cur.offset, p.cur.line = p.offset, p.line
 	p.cur.unquoted = ""
 	switch p.s[0] {
 	case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
 		// Single symbol
 		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
 	case '"', '\'':
 		// Quoted string
 		i := 1
 		for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
 			if p.s[i] == '\\' && i+1 < len(p.s) {
 				// skip escaped char
 				i++
 			}
 			i++
 		}
 		if i >= len(p.s) || p.s[i] != p.s[0] {
 			p.errorf("unmatched quote")
 			return
 		}
 		unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
 		if err != nil {
 			p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
 			return
 		}
 		p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
 		p.cur.unquoted = unq
 	default:
 		i := 0
 		for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
 			i++
 		}
 		if i == 0 {
 			p.errorf("unexpected byte %#x", p.s[0])
 			return
 		}
 		p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
 	}
 	p.offset += len(p.cur.value)
 }
 var (
 	errBadUTF8 = errors.New("proto: bad UTF-8")
 )
 func unquoteC(s string, quote rune) (string, error) {
 	// This is based on C++'s tokenizer.cc.
 	// Despite its name, this is *not* parsing C syntax.
 	// For instance, "\0" is an invalid quoted string.
 	// Avoid allocation in trivial cases.
 	simple := true
 	for _, r := range s {
 		if r == '\\' || r == quote {
 			simple = false
 			break
 		}
 	}
 	if simple {
 		return s, nil
 	}
 	buf := make([]byte, 0, 3*len(s)/2)
 	for len(s) > 0 {
 		r, n := utf8.DecodeRuneInString(s)
 		if r == utf8.RuneError && n == 1 {
 			return "", errBadUTF8
 		}
 		s = s[n:]
 		if r != '\\' {
 			if r < utf8.RuneSelf {
 				buf = append(buf, byte(r))
 			} else {
 				buf = append(buf, string(r)...)
 			}
 			continue
 		}
 		ch, tail, err := unescape(s)
 		if err != nil {
 			return "", err
 		}
 		buf = append(buf, ch...)
 		s = tail
 	}
 	return string(buf), nil
 }
 func unescape(s string) (ch string, tail string, err error) {
 	r, n := utf8.DecodeRuneInString(s)
 	if r == utf8.RuneError && n == 1 {
 		return "", "", errBadUTF8
 	}
 	s = s[n:]
 	switch r {
 	case 'a':
 		return "\a", s, nil
 	case 'b':
 		return "\b", s, nil
 	case 'f':
 		return "\f", s, nil
 	case 'n':
 		return "\n", s, nil
 	case 'r':
 		return "\r", s, nil
 	case 't':
 		return "\t", s, nil
 	case 'v':
 		return "\v", s, nil
 	case '?':
 		return "?", s, nil // trigraph workaround
 	case '\'', '"', '\\':
 		return string(r), s, nil
 	case '0', '1', '2', '3', '4', '5', '6', '7':
 		if len(s) < 2 {
 			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
 		}
 		ss := string(r) + s[:2]
 		s = s[2:]
 		i, err := strconv.ParseUint(ss, 8, 8)
 		if err != nil {
 			return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
 		}
 		return string([]byte{byte(i)}), s, nil
 	case 'x', 'X', 'u', 'U':
 		var n int
 		switch r {
 		case 'x', 'X':
 			n = 2
 		case 'u':
 			n = 4
 		case 'U':
 			n = 8
 		}
 		if len(s) < n {
 			return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
 		}
 		ss := s[:n]
 		s = s[n:]
 		i, err := strconv.ParseUint(ss, 16, 64)
 		if err != nil {
 			return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
 		}
 		if r == 'x' || r == 'X' {
 			return string([]byte{byte(i)}), s, nil
 		}
 		if i > utf8.MaxRune {
 			return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
 		}
 		return string(i), s, nil
 	}
 	return "", "", fmt.Errorf(`unknown escape \%c`, r)
 }
 // Back off the parser by one token. Can only be done between calls to next().
 // It makes the next advance() a no-op.
 func (p *textParser) back() { p.backed = true }
 // Advances the parser and returns the new current token.
 func (p *textParser) next() *token {
 	if p.backed || p.done {
 		p.backed = false
 		return &p.cur
 	}
 	p.advance()
 	if p.done {
 		p.cur.value = ""
 	} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
 		// Look for multiple quoted strings separated by whitespace,
 		// and concatenate them.
 		cat := p.cur
 		for {
 			p.skipWhitespace()
 			if p.done || !isQuote(p.s[0]) {
 				break
 			}
 			p.advance()
 			if p.cur.err != nil {
 				return &p.cur
 			}
 			cat.value += " " + p.cur.value
 			cat.unquoted += p.cur.unquoted
 		}
 		p.done = false // parser may have seen EOF, but we want to return cat
 		p.cur = cat
 	}
 	return &p.cur
 }
 func (p *textParser) consumeToken(s string) error {
 	tok := p.next()
 	if tok.err != nil {
 		return tok.err
 	}
 	if tok.value != s {
 		p.back()
 		return p.errorf("expected %q, found %q", s, tok.value)
 	}
 	return nil
 }
 // Return a RequiredNotSetError indicating which required field was not set.
 func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
 	st := sv.Type()
 	sprops := GetProperties(st)
 	for i := 0; i < st.NumField(); i++ {
 		if !isNil(sv.Field(i)) {
 			continue
 		}
 		props := sprops.Prop[i]
 		if props.Required {
 			return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
 		}
 	}
 	return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
 }
 // Returns the index in the struct for the named field, as well as the parsed tag properties.
 func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
 	i, ok := sprops.decoderOrigNames[name]
 	if ok {
 		return i, sprops.Prop[i], true
 	}
 	return -1, nil, false
 }
 // Consume a ':' from the input stream (if the next token is a colon),
 // returning an error if a colon is needed but not present.
 func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
 	tok := p.next()
 	if tok.err != nil {
 		return tok.err
 	}
 	if tok.value != ":" {
 		// Colon is optional when the field is a group or message.
 		needColon := true
 		switch props.Wire {
 		case "group":
 			needColon = false
 		case "bytes":
 			// A "bytes" field is either a message, a string, or a repeated field;
 			// those three become *T, *string and []T respectively, so we can check for
 			// this field being a pointer to a non-string.
 			if typ.Kind() == reflect.Ptr {
 				// *T or *string
 				if typ.Elem().Kind() == reflect.String {
 					break
 				}
 			} else if typ.Kind() == reflect.Slice {
 				// []T or []*T
 				if typ.Elem().Kind() != reflect.Ptr {
 					break
 				}
 			} else if typ.Kind() == reflect.String {
 				// The proto3 exception is for a string field,
 				// which requires a colon.
 				break
 			}
 			needColon = false
 		}
 		if needColon {
 			return p.errorf("expected ':', found %q", tok.value)
 		}
 		p.back()
 	}
 	return nil
 }
 func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
 	st := sv.Type()
 	sprops := GetProperties(st)
 	reqCount := sprops.reqCount
 	var reqFieldErr error
 	fieldSet := make(map[string]bool)
 	// A struct is a sequence of "name: value", terminated by one of
 	// '>' or '}', or the end of the input.  A name may also be
 	// "[extension]" or "[type/url]".
 	//
 	// The whole struct can also be an expanded Any message, like:
 	// [type/url] < ... struct contents ... >
 	for {
 		tok := p.next()
 		if tok.err != nil {
 			return tok.err
 		}
 		if tok.value == terminator {
 			break
 		}
 		if tok.value == "[" {
 			// Looks like an extension or an Any.
 			//
 			// TODO: Check whether we need to handle
 			// namespace rooted names (e.g. ".something.Foo").
 			extName, err := p.consumeExtName()
 			if err != nil {
 				return err
 			}
 			if s := strings.LastIndex(extName, "/"); s >= 0 {
 				// If it contains a slash, it's an Any type URL.
 				messageName := extName[s+1:]
 				mt := MessageType(messageName)
 				if mt == nil {
 					return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
 				}
 				tok = p.next()
 				if tok.err != nil {
 					return tok.err
 				}
 				// consume an optional colon
 				if tok.value == ":" {
 					tok = p.next()
 					if tok.err != nil {
 						return tok.err
 					}
 				}
 				var terminator string
 				switch tok.value {
 				case "<":
 					terminator = ">"
 				case "{":
 					terminator = "}"
 				default:
 					return p.errorf("expected '{' or '<', found %q", tok.value)
 				}
 				v := reflect.New(mt.Elem())
 				if pe := p.readStruct(v.Elem(), terminator); pe != nil {
 					return pe
 				}
 				b, err := Marshal(v.Interface().(Message))
 				if err != nil {
 					return p.errorf("failed to marshal message of type %q: %v", messageName, err)
 				}
 				if fieldSet["type_url"] {
 					return p.errorf(anyRepeatedlyUnpacked, "type_url")
 				}
 				if fieldSet["value"] {
 					return p.errorf(anyRepeatedlyUnpacked, "value")
 				}
 				sv.FieldByName("TypeUrl").SetString(extName)
 				sv.FieldByName("Value").SetBytes(b)
 				fieldSet["type_url"] = true
 				fieldSet["value"] = true
 				continue
 			}
 			var desc *ExtensionDesc
 			// This could be faster, but it's functional.
 			// TODO: Do something smarter than a linear scan.
 			for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
 				if d.Name == extName {
 					desc = d
 					break
 				}
 			}
 			if desc == nil {
 				return p.errorf("unrecognized extension %q", extName)
 			}
 			props := &Properties{}
 			props.Parse(desc.Tag)
 			typ := reflect.TypeOf(desc.ExtensionType)
 			if err := p.checkForColon(props, typ); err != nil {
 				return err
 			}
 			rep := desc.repeated()
 			// Read the extension structure, and set it in
 			// the value we're constructing.
 			var ext reflect.Value
 			if !rep {
 				ext = reflect.New(typ).Elem()
 			} else {
 				ext = reflect.New(typ.Elem()).Elem()
 			}
 			if err := p.readAny(ext, props); err != nil {
 				if _, ok := err.(*RequiredNotSetError); !ok {
 					return err
 				}
 				reqFieldErr = err
 			}
 			ep := sv.Addr().Interface().(Message)
 			if !rep {
 				SetExtension(ep, desc, ext.Interface())
 			} else {
 				old, err := GetExtension(ep, desc)
 				var sl reflect.Value
 				if err == nil {
 					sl = reflect.ValueOf(old) // existing slice
 				} else {
 					sl = reflect.MakeSlice(typ, 0, 1)
 				}
 				sl = reflect.Append(sl, ext)
 				SetExtension(ep, desc, sl.Interface())
 			}
 			if err := p.consumeOptionalSeparator(); err != nil {
 				return err
 			}
 			continue
 		}
 		// This is a normal, non-extension field.
 		name := tok.value
 		var dst reflect.Value
 		fi, props, ok := structFieldByName(sprops, name)
 		if ok {
 			dst = sv.Field(fi)
 		} else if oop, ok := sprops.OneofTypes[name]; ok {
 			// It is a oneof.
 			props = oop.Prop
 			nv := reflect.New(oop.Type.Elem())
 			dst = nv.Elem().Field(0)
 			field := sv.Field(oop.Field)
 			if !field.IsNil() {
 				return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
 			}
 			field.Set(nv)
 		}
 		if !dst.IsValid() {
 			return p.errorf("unknown field name %q in %v", name, st)
 		}
 		if dst.Kind() == reflect.Map {
 			// Consume any colon.
 			if err := p.checkForColon(props, dst.Type()); err != nil {
 				return err
 			}
 			// Construct the map if it doesn't already exist.
 			if dst.IsNil() {
 				dst.Set(reflect.MakeMap(dst.Type()))
 			}
 			key := reflect.New(dst.Type().Key()).Elem()
 			val := reflect.New(dst.Type().Elem()).Elem()
 			// The map entry should be this sequence of tokens:
 			//	< key : KEY value : VALUE >
 			// However, implementations may omit key or value, and technically
 			// we should support them in any order.  See b/28924776 for a time
 			// this went wrong.
 			tok := p.next()
 			var terminator string
 			switch tok.value {
 			case "<":
 				terminator = ">"
 			case "{":
 				terminator = "}"
 			default:
 				return p.errorf("expected '{' or '<', found %q", tok.value)
 			}
 			for {
 				tok := p.next()
 				if tok.err != nil {
 					return tok.err
 				}
 				if tok.value == terminator {
 					break
 				}
 				switch tok.value {
 				case "key":
 					if err := p.consumeToken(":"); err != nil {
 						return err
 					}
 					if err := p.readAny(key, props.MapKeyProp); err != nil {
 						return err
 					}
 					if err := p.consumeOptionalSeparator(); err != nil {
 						return err
 					}
 				case "value":
 					if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil {
 						return err
 					}
 					if err := p.readAny(val, props.MapValProp); err != nil {
 						return err
 					}
 					if err := p.consumeOptionalSeparator(); err != nil {
 						return err
 					}
 				default:
 					p.back()
 					return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
 				}
 			}
 			dst.SetMapIndex(key, val)
 			continue
 		}
 		// Check that it's not already set if it's not a repeated field.
 		if !props.Repeated && fieldSet[name] {
 			return p.errorf("non-repeated field %q was repeated", name)
 		}
 		if err := p.checkForColon(props, dst.Type()); err != nil {
 			return err
 		}
 		// Parse into the field.
 		fieldSet[name] = true
 		if err := p.readAny(dst, props); err != nil {
 			if _, ok := err.(*RequiredNotSetError); !ok {
 				return err
 			}
 			reqFieldErr = err
 		}
 		if props.Required {
 			reqCount--
 		}
 		if err := p.consumeOptionalSeparator(); err != nil {
 			return err
 		}
 	}
 	if reqCount > 0 {
 		return p.missingRequiredFieldError(sv)
 	}
 	return reqFieldErr
 }
 // consumeExtName consumes extension name or expanded Any type URL and the
 // following ']'. It returns the name or URL consumed.
 func (p *textParser) consumeExtName() (string, error) {
 	tok := p.next()
 	if tok.err != nil {
 		return "", tok.err
 	}
 	// If extension name or type url is quoted, it's a single token.
 	if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
 		name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
 		if err != nil {
 			return "", err
 		}
 		return name, p.consumeToken("]")
 	}
 	// Consume everything up to "]"
 	var parts []string
 	for tok.value != "]" {
 		parts = append(parts, tok.value)
 		tok = p.next()
 		if tok.err != nil {
 			return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
 		}
 		if p.done && tok.value != "]" {
 			return "", p.errorf("unclosed type_url or extension name")
 		}
 	}
 	return strings.Join(parts, ""), nil
 }
 // consumeOptionalSeparator consumes an optional semicolon or comma.
 // It is used in readStruct to provide backward compatibility.
 func (p *textParser) consumeOptionalSeparator() error {
 	tok := p.next()
 	if tok.err != nil {
 		return tok.err
 	}
 	if tok.value != ";" && tok.value != "," {
 		p.back()
 	}
 	return nil
 }
 func (p *textParser) readAny(v reflect.Value, props *Properties) error {
 	tok := p.next()
 	if tok.err != nil {
 		return tok.err
 	}
 	if tok.value == "" {
 		return p.errorf("unexpected EOF")
 	}
 	switch fv := v; fv.Kind() {
 	case reflect.Slice:
 		at := v.Type()
 		if at.Elem().Kind() == reflect.Uint8 {
 			// Special case for []byte
 			if tok.value[0] != '"' && tok.value[0] != '\'' {
 				// Deliberately written out here, as the error after
 				// this switch statement would write "invalid []byte: ...",
 				// which is not as user-friendly.
 				return p.errorf("invalid string: %v", tok.value)
 			}
 			bytes := []byte(tok.unquoted)
 			fv.Set(reflect.ValueOf(bytes))
 			return nil
 		}
 		// Repeated field.
 		if tok.value == "[" {
 			// Repeated field with list notation, like [1,2,3].
 			for {
 				fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
 				err := p.readAny(fv.Index(fv.Len()-1), props)
 				if err != nil {
 					return err
 				}
 				tok := p.next()
 				if tok.err != nil {
 					return tok.err
 				}
 				if tok.value == "]" {
 					break
 				}
 				if tok.value != "," {
 					return p.errorf("Expected ']' or ',' found %q", tok.value)
 				}
 			}
 			return nil
 		}
 		// One value of the repeated field.
 		p.back()
 		fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
 		return p.readAny(fv.Index(fv.Len()-1), props)
 	case reflect.Bool:
 		// true/1/t/True or false/f/0/False.
 		switch tok.value {
 		case "true", "1", "t", "True":
 			fv.SetBool(true)
 			return nil
 		case "false", "0", "f", "False":
 			fv.SetBool(false)
 			return nil
 		}
 	case reflect.Float32, reflect.Float64:
 		v := tok.value
 		// Ignore 'f' for compatibility with output generated by C++, but don't
 		// remove 'f' when the value is "-inf" or "inf".
 		if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
 			v = v[:len(v)-1]
 		}
 		if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
 			fv.SetFloat(f)
 			return nil
 		}
 	case reflect.Int32:
 		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
 			fv.SetInt(x)
 			return nil
 		}
 		if len(props.Enum) == 0 {
 			break
 		}
 		m, ok := enumValueMaps[props.Enum]
 		if !ok {
 			break
 		}
 		x, ok := m[tok.value]
 		if !ok {
 			break
 		}
 		fv.SetInt(int64(x))
 		return nil
 	case reflect.Int64:
 		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
 			fv.SetInt(x)
 			return nil
 		}
 	case reflect.Ptr:
 		// A basic field (indirected through pointer), or a repeated message/group
 		p.back()
 		fv.Set(reflect.New(fv.Type().Elem()))
 		return p.readAny(fv.Elem(), props)
 	case reflect.String:
 		if tok.value[0] == '"' || tok.value[0] == '\'' {
 			fv.SetString(tok.unquoted)
 			return nil
 		}
 	case reflect.Struct:
 		var terminator string
 		switch tok.value {
 		case "{":
 			terminator = "}"
 		case "<":
 			terminator = ">"
 		default:
 			return p.errorf("expected '{' or '<', found %q", tok.value)
 		}
 		// TODO: Handle nested messages which implement encoding.TextUnmarshaler.
 		return p.readStruct(fv, terminator)
 	case reflect.Uint32:
 		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
 			fv.SetUint(uint64(x))
 			return nil
 		}
 	case reflect.Uint64:
 		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
 			fv.SetUint(x)
 			return nil
 		}
 	}
 	return p.errorf("invalid %v: %v", v.Type(), tok.value)
 }
 // UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
 // before starting to unmarshal, so any existing data in pb is always removed.
 // If a required field is not set and no other error occurs,
 // UnmarshalText returns *RequiredNotSetError.
 func UnmarshalText(s string, pb Message) error {
 	if um, ok := pb.(encoding.TextUnmarshaler); ok {
 		return um.UnmarshalText([]byte(s))
 	}
 	pb.Reset()
 	v := reflect.ValueOf(pb)
 	return newTextParser(s).readStruct(v.Elem(), "")
 }
--- a/vendor/github.com/golang/protobuf/ptypes/any.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any.go
@@ -0,0 +1,141 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2016 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package ptypes
 // This file implements functions to marshal proto.Message to/from
 // google.protobuf.Any message.
 import (
 	"fmt"
 	"reflect"
 	"strings"
 	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/ptypes/any"
 )
 const googleApis = "type.googleapis.com/"
 // AnyMessageName returns the name of the message contained in a google.protobuf.Any message.
 //
 // Note that regular type assertions should be done using the Is
 // function. AnyMessageName is provided for less common use cases like filtering a
 // sequence of Any messages based on a set of allowed message type names.
 func AnyMessageName(any *any.Any) (string, error) {
 	if any == nil {
 		return "", fmt.Errorf("message is nil")
 	}
 	slash := strings.LastIndex(any.TypeUrl, "/")
 	if slash < 0 {
 		return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl)
 	}
 	return any.TypeUrl[slash+1:], nil
 }
 // MarshalAny takes the protocol buffer and encodes it into google.protobuf.Any.
 func MarshalAny(pb proto.Message) (*any.Any, error) {
 	value, err := proto.Marshal(pb)
 	if err != nil {
 		return nil, err
 	}
 	return &any.Any{TypeUrl: googleApis + proto.MessageName(pb), Value: value}, nil
 }
 // DynamicAny is a value that can be passed to UnmarshalAny to automatically
 // allocate a proto.Message for the type specified in a google.protobuf.Any
 // message. The allocated message is stored in the embedded proto.Message.
 //
 // Example:
 //
 //   var x ptypes.DynamicAny
 //   if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
 //   fmt.Printf("unmarshaled message: %v", x.Message)
 type DynamicAny struct {
 	proto.Message
 }
 // Empty returns a new proto.Message of the type specified in a
 // google.protobuf.Any message. It returns an error if corresponding message
 // type isn't linked in.
 func Empty(any *any.Any) (proto.Message, error) {
 	aname, err := AnyMessageName(any)
 	if err != nil {
 		return nil, err
 	}
 	t := proto.MessageType(aname)
 	if t == nil {
 		return nil, fmt.Errorf("any: message type %q isn't linked in", aname)
 	}
 	return reflect.New(t.Elem()).Interface().(proto.Message), nil
 }
 // UnmarshalAny parses the protocol buffer representation in a google.protobuf.Any
 // message and places the decoded result in pb. It returns an error if type of
 // contents of Any message does not match type of pb message.
 //
 // pb can be a proto.Message, or a *DynamicAny.
 func UnmarshalAny(any *any.Any, pb proto.Message) error {
 	if d, ok := pb.(*DynamicAny); ok {
 		if d.Message == nil {
 			var err error
 			d.Message, err = Empty(any)
 			if err != nil {
 				return err
 			}
 		}
 		return UnmarshalAny(any, d.Message)
 	}
 	aname, err := AnyMessageName(any)
 	if err != nil {
 		return err
 	}
 	mname := proto.MessageName(pb)
 	if aname != mname {
 		return fmt.Errorf("mismatched message type: got %q want %q", aname, mname)
 	}
 	return proto.Unmarshal(any.Value, pb)
 }
 // Is returns true if any value contains a given message type.
 func Is(any *any.Any, pb proto.Message) bool {
 	// The following is equivalent to AnyMessageName(any) == proto.MessageName(pb),
 	// but it avoids scanning TypeUrl for the slash.
 	if any == nil {
 		return false
 	}
 	name := proto.MessageName(pb)
 	prefix := len(any.TypeUrl) - len(name)
 	return prefix >= 1 && any.TypeUrl[prefix-1] == '/' && any.TypeUrl[prefix:] == name
 }
--- a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
@@ -0,0 +1,195 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: google/protobuf/any.proto
 package any
 import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	math "math"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 // `Any` contains an arbitrary serialized protocol buffer message along with a
 // URL that describes the type of the serialized message.
 //
 // Protobuf library provides support to pack/unpack Any values in the form
 // of utility functions or additional generated methods of the Any type.
 //
 // Example 1: Pack and unpack a message in C++.
 //
 //     Foo foo = ...;
 //     Any any;
 //     any.PackFrom(foo);
 //     ...
 //     if (any.UnpackTo(&foo)) {
 //       ...
 //     }
 //
 // Example 2: Pack and unpack a message in Java.
 //
 //     Foo foo = ...;
 //     Any any = Any.pack(foo);
 //     ...
 //     if (any.is(Foo.class)) {
 //       foo = any.unpack(Foo.class);
 //     }
 //
 //  Example 3: Pack and unpack a message in Python.
 //
 //     foo = Foo(...)
 //     any = Any()
 //     any.Pack(foo)
 //     ...
 //     if any.Is(Foo.DESCRIPTOR):
 //       any.Unpack(foo)
 //       ...
 //
 //  Example 4: Pack and unpack a message in Go
 //
 //      foo := &pb.Foo{...}
 //      any, err := ptypes.MarshalAny(foo)
 //      ...
 //      foo := &pb.Foo{}
 //      if err := ptypes.UnmarshalAny(any, foo); err != nil {
 //        ...
 //      }
 //
 // The pack methods provided by protobuf library will by default use
 // 'type.googleapis.com/full.type.name' as the type URL and the unpack
 // methods only use the fully qualified type name after the last '/'
 // in the type URL, for example "foo.bar.com/x/y.z" will yield type
 // name "y.z".
 //
 //
 // JSON
 // ====
 // The JSON representation of an `Any` value uses the regular
 // representation of the deserialized, embedded message, with an
 // additional field `@type` which contains the type URL. Example:
 //
 //     package google.profile;
 //     message Person {
 //       string first_name = 1;
 //       string last_name = 2;
 //     }
 //
 //     {
 //       "@type": "type.googleapis.com/google.profile.Person",
 //       "firstName": <string>,
 //       "lastName": <string>
 //     }
 //
 // If the embedded message type is well-known and has a custom JSON
 // representation, that representation will be embedded adding a field
 // `value` which holds the custom JSON in addition to the `@type`
 // field. Example (for message [google.protobuf.Duration][]):
 //
 //     {
 //       "@type": "type.googleapis.com/google.protobuf.Duration",
 //       "value": "1.212s"
 //     }
 //
 type Any struct {
 	// A URL/resource name whose content describes the type of the
 	// serialized protocol buffer message.
 	//
 	// For URLs which use the scheme `http`, `https`, or no scheme, the
 	// following restrictions and interpretations apply:
 	//
 	// * If no scheme is provided, `https` is assumed.
 	// * The last segment of the URL's path must represent the fully
 	//   qualified name of the type (as in `path/google.protobuf.Duration`).
 	//   The name should be in a canonical form (e.g., leading "." is
 	//   not accepted).
 	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
 	//   value in binary format, or produce an error.
 	// * Applications are allowed to cache lookup results based on the
 	//   URL, or have them precompiled into a binary to avoid any
 	//   lookup. Therefore, binary compatibility needs to be preserved
 	//   on changes to types. (Use versioned type names to manage
 	//   breaking changes.)
 	//
 	// Schemes other than `http`, `https` (or the empty scheme) might be
 	// used with implementation specific semantics.
 	//
 	TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"`
 	// Must be a valid serialized protocol buffer of the above specified type.
 	Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
 }
 func (m *Any) Reset()         { *m = Any{} }
 func (m *Any) String() string { return proto.CompactTextString(m) }
 func (*Any) ProtoMessage()    {}
 func (*Any) Descriptor() ([]byte, []int) {
 	return fileDescriptor_b53526c13ae22eb4, []int{0}
 }
 func (*Any) XXX_WellKnownType() string { return "Any" }
 func (m *Any) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Any.Unmarshal(m, b)
 }
 func (m *Any) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Any.Marshal(b, m, deterministic)
 }
 func (m *Any) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Any.Merge(m, src)
 }
 func (m *Any) XXX_Size() int {
 	return xxx_messageInfo_Any.Size(m)
 }
 func (m *Any) XXX_DiscardUnknown() {
 	xxx_messageInfo_Any.DiscardUnknown(m)
 }
 var xxx_messageInfo_Any proto.InternalMessageInfo
 func (m *Any) GetTypeUrl() string {
 	if m != nil {
 		return m.TypeUrl
 	}
 	return ""
 }
 func (m *Any) GetValue() []byte {
 	if m != nil {
 		return m.Value
 	}
 	return nil
 }
 func init() {
 	proto.RegisterType((*Any)(nil), "google.protobuf.Any")
 }
 func init() { proto.RegisterFile("google/protobuf/any.proto", fileDescriptor_b53526c13ae22eb4) }
 var fileDescriptor_b53526c13ae22eb4 = []byte{
 	// 185 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f,
 	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcc, 0xab, 0xd4,
 	0x03, 0x73, 0x84, 0xf8, 0x21, 0x52, 0x7a, 0x30, 0x29, 0x25, 0x33, 0x2e, 0x66, 0xc7, 0xbc, 0x4a,
 	0x21, 0x49, 0x2e, 0x8e, 0x92, 0xca, 0x82, 0xd4, 0xf8, 0xd2, 0xa2, 0x1c, 0x09, 0x46, 0x05, 0x46,
 	0x0d, 0xce, 0x20, 0x76, 0x10, 0x3f, 0xb4, 0x28, 0x47, 0x48, 0x84, 0x8b, 0xb5, 0x2c, 0x31, 0xa7,
 	0x34, 0x55, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27, 0x08, 0xc2, 0x71, 0xca, 0xe7, 0x12, 0x4e, 0xce,
 	0xcf, 0xd5, 0x43, 0x33, 0xce, 0x89, 0xc3, 0x31, 0xaf, 0x32, 0x00, 0xc4, 0x09, 0x60, 0x8c, 0x52,
 	0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc,
 	0x4b, 0x47, 0xb8, 0xa8, 0x00, 0x64, 0x7a, 0x31, 0xc8, 0x61, 0x8b, 0x98, 0x98, 0xdd, 0x03, 0x9c,
 	0x56, 0x31, 0xc9, 0xb9, 0x43, 0x8c, 0x0a, 0x80, 0x2a, 0xd1, 0x0b, 0x4f, 0xcd, 0xc9, 0xf1, 0xce,
 	0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0x29, 0x4d, 0x62, 0x03, 0xeb, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff,
 	0xff, 0x13, 0xf8, 0xe8, 0x42, 0xdd, 0x00, 0x00, 0x00,
 }
--- a/vendor/github.com/golang/protobuf/ptypes/any/any.proto
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
@@ -0,0 +1,149 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // 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.
 syntax = "proto3";
 package google.protobuf;
 option csharp_namespace = "Google.Protobuf.WellKnownTypes";
 option go_package = "github.com/golang/protobuf/ptypes/any";
 option java_package = "com.google.protobuf";
 option java_outer_classname = "AnyProto";
 option java_multiple_files = true;
 option objc_class_prefix = "GPB";
 // `Any` contains an arbitrary serialized protocol buffer message along with a
 // URL that describes the type of the serialized message.
 //
 // Protobuf library provides support to pack/unpack Any values in the form
 // of utility functions or additional generated methods of the Any type.
 //
 // Example 1: Pack and unpack a message in C++.
 //
 //     Foo foo = ...;
 //     Any any;
 //     any.PackFrom(foo);
 //     ...
 //     if (any.UnpackTo(&foo)) {
 //       ...
 //     }
 //
 // Example 2: Pack and unpack a message in Java.
 //
 //     Foo foo = ...;
 //     Any any = Any.pack(foo);
 //     ...
 //     if (any.is(Foo.class)) {
 //       foo = any.unpack(Foo.class);
 //     }
 //
 //  Example 3: Pack and unpack a message in Python.
 //
 //     foo = Foo(...)
 //     any = Any()
 //     any.Pack(foo)
 //     ...
 //     if any.Is(Foo.DESCRIPTOR):
 //       any.Unpack(foo)
 //       ...
 //
 //  Example 4: Pack and unpack a message in Go
 //
 //      foo := &pb.Foo{...}
 //      any, err := ptypes.MarshalAny(foo)
 //      ...
 //      foo := &pb.Foo{}
 //      if err := ptypes.UnmarshalAny(any, foo); err != nil {
 //        ...
 //      }
 //
 // The pack methods provided by protobuf library will by default use
 // 'type.googleapis.com/full.type.name' as the type URL and the unpack
 // methods only use the fully qualified type name after the last '/'
 // in the type URL, for example "foo.bar.com/x/y.z" will yield type
 // name "y.z".
 //
 //
 // JSON
 // ====
 // The JSON representation of an `Any` value uses the regular
 // representation of the deserialized, embedded message, with an
 // additional field `@type` which contains the type URL. Example:
 //
 //     package google.profile;
 //     message Person {
 //       string first_name = 1;
 //       string last_name = 2;
 //     }
 //
 //     {
 //       "@type": "type.googleapis.com/google.profile.Person",
 //       "firstName": <string>,
 //       "lastName": <string>
 //     }
 //
 // If the embedded message type is well-known and has a custom JSON
 // representation, that representation will be embedded adding a field
 // `value` which holds the custom JSON in addition to the `@type`
 // field. Example (for message [google.protobuf.Duration][]):
 //
 //     {
 //       "@type": "type.googleapis.com/google.protobuf.Duration",
 //       "value": "1.212s"
 //     }
 //
 message Any {
  // A URL/resource name whose content describes the type of the
  // serialized protocol buffer message.
  //
  // For URLs which use the scheme `http`, `https`, or no scheme, the
  // following restrictions and interpretations apply:
  //
  // * If no scheme is provided, `https` is assumed.
  // * The last segment of the URL's path must represent the fully
  //   qualified name of the type (as in `path/google.protobuf.Duration`).
  //   The name should be in a canonical form (e.g., leading "." is
  //   not accepted).
  // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
  //   value in binary format, or produce an error.
  // * Applications are allowed to cache lookup results based on the
  //   URL, or have them precompiled into a binary to avoid any
  //   lookup. Therefore, binary compatibility needs to be preserved
  //   on changes to types. (Use versioned type names to manage
  //   breaking changes.)
  //
  // Schemes other than `http`, `https` (or the empty scheme) might be
  // used with implementation specific semantics.
  //
  string type_url = 1;
  // Must be a valid serialized protocol buffer of the above specified type.
  bytes value = 2;
 }
--- a/vendor/github.com/golang/protobuf/ptypes/doc.go
+++ b/vendor/github.com/golang/protobuf/ptypes/doc.go
@@ -0,0 +1,35 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2016 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /*
 Package ptypes contains code for interacting with well-known types.
 */
 package ptypes
--- a/vendor/github.com/golang/protobuf/ptypes/duration.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration.go
@@ -0,0 +1,102 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2016 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package ptypes
 // This file implements conversions between google.protobuf.Duration
 // and time.Duration.
 import (
 	"errors"
 	"fmt"
 	"time"
 	durpb "github.com/golang/protobuf/ptypes/duration"
 )
 const (
 	// Range of a durpb.Duration in seconds, as specified in
 	// google/protobuf/duration.proto. This is about 10,000 years in seconds.
 	maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60)
 	minSeconds = -maxSeconds
 )
 // validateDuration determines whether the durpb.Duration is valid according to the
 // definition in google/protobuf/duration.proto. A valid durpb.Duration
 // may still be too large to fit into a time.Duration (the range of durpb.Duration
 // is about 10,000 years, and the range of time.Duration is about 290).
 func validateDuration(d *durpb.Duration) error {
 	if d == nil {
 		return errors.New("duration: nil Duration")
 	}
 	if d.Seconds < minSeconds || d.Seconds > maxSeconds {
 		return fmt.Errorf("duration: %v: seconds out of range", d)
 	}
 	if d.Nanos <= -1e9 || d.Nanos >= 1e9 {
 		return fmt.Errorf("duration: %v: nanos out of range", d)
 	}
 	// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
 	if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) {
 		return fmt.Errorf("duration: %v: seconds and nanos have different signs", d)
 	}
 	return nil
 }
 // Duration converts a durpb.Duration to a time.Duration. Duration
 // returns an error if the durpb.Duration is invalid or is too large to be
 // represented in a time.Duration.
 func Duration(p *durpb.Duration) (time.Duration, error) {
 	if err := validateDuration(p); err != nil {
 		return 0, err
 	}
 	d := time.Duration(p.Seconds) * time.Second
 	if int64(d/time.Second) != p.Seconds {
 		return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
 	}
 	if p.Nanos != 0 {
 		d += time.Duration(p.Nanos)
 		if (d < 0) != (p.Nanos < 0) {
 			return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
 		}
 	}
 	return d, nil
 }
 // DurationProto converts a time.Duration to a durpb.Duration.
 func DurationProto(d time.Duration) *durpb.Duration {
 	nanos := d.Nanoseconds()
 	secs := nanos / 1e9
 	nanos -= secs * 1e9
 	return &durpb.Duration{
 		Seconds: secs,
 		Nanos:   int32(nanos),
 	}
 }
--- a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
@@ -0,0 +1,161 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: google/protobuf/duration.proto
 package duration
 import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	math "math"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 // A Duration represents a signed, fixed-length span of time represented
 // as a count of seconds and fractions of seconds at nanosecond
 // resolution. It is independent of any calendar and concepts like "day"
 // or "month". It is related to Timestamp in that the difference between
 // two Timestamp values is a Duration and it can be added or subtracted
 // from a Timestamp. Range is approximately +-10,000 years.
 //
 // # Examples
 //
 // Example 1: Compute Duration from two Timestamps in pseudo code.
 //
 //     Timestamp start = ...;
 //     Timestamp end = ...;
 //     Duration duration = ...;
 //
 //     duration.seconds = end.seconds - start.seconds;
 //     duration.nanos = end.nanos - start.nanos;
 //
 //     if (duration.seconds < 0 && duration.nanos > 0) {
 //       duration.seconds += 1;
 //       duration.nanos -= 1000000000;
 //     } else if (durations.seconds > 0 && duration.nanos < 0) {
 //       duration.seconds -= 1;
 //       duration.nanos += 1000000000;
 //     }
 //
 // Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
 //
 //     Timestamp start = ...;
 //     Duration duration = ...;
 //     Timestamp end = ...;
 //
 //     end.seconds = start.seconds + duration.seconds;
 //     end.nanos = start.nanos + duration.nanos;
 //
 //     if (end.nanos < 0) {
 //       end.seconds -= 1;
 //       end.nanos += 1000000000;
 //     } else if (end.nanos >= 1000000000) {
 //       end.seconds += 1;
 //       end.nanos -= 1000000000;
 //     }
 //
 // Example 3: Compute Duration from datetime.timedelta in Python.
 //
 //     td = datetime.timedelta(days=3, minutes=10)
 //     duration = Duration()
 //     duration.FromTimedelta(td)
 //
 // # JSON Mapping
 //
 // In JSON format, the Duration type is encoded as a string rather than an
 // object, where the string ends in the suffix "s" (indicating seconds) and
 // is preceded by the number of seconds, with nanoseconds expressed as
 // fractional seconds. For example, 3 seconds with 0 nanoseconds should be
 // encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
 // be expressed in JSON format as "3.000000001s", and 3 seconds and 1
 // microsecond should be expressed in JSON format as "3.000001s".
 //
 //
 type Duration struct {
 	// Signed seconds of the span of time. Must be from -315,576,000,000
 	// to +315,576,000,000 inclusive. Note: these bounds are computed from:
 	// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
 	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
 	// Signed fractions of a second at nanosecond resolution of the span
 	// of time. Durations less than one second are represented with a 0
 	// `seconds` field and a positive or negative `nanos` field. For durations
 	// of one second or more, a non-zero value for the `nanos` field must be
 	// of the same sign as the `seconds` field. Must be from -999,999,999
 	// to +999,999,999 inclusive.
 	Nanos                int32    `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
 }
 func (m *Duration) Reset()         { *m = Duration{} }
 func (m *Duration) String() string { return proto.CompactTextString(m) }
 func (*Duration) ProtoMessage()    {}
 func (*Duration) Descriptor() ([]byte, []int) {
 	return fileDescriptor_23597b2ebd7ac6c5, []int{0}
 }
 func (*Duration) XXX_WellKnownType() string { return "Duration" }
 func (m *Duration) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Duration.Unmarshal(m, b)
 }
 func (m *Duration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Duration.Marshal(b, m, deterministic)
 }
 func (m *Duration) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Duration.Merge(m, src)
 }
 func (m *Duration) XXX_Size() int {
 	return xxx_messageInfo_Duration.Size(m)
 }
 func (m *Duration) XXX_DiscardUnknown() {
 	xxx_messageInfo_Duration.DiscardUnknown(m)
 }
 var xxx_messageInfo_Duration proto.InternalMessageInfo
 func (m *Duration) GetSeconds() int64 {
 	if m != nil {
 		return m.Seconds
 	}
 	return 0
 }
 func (m *Duration) GetNanos() int32 {
 	if m != nil {
 		return m.Nanos
 	}
 	return 0
 }
 func init() {
 	proto.RegisterType((*Duration)(nil), "google.protobuf.Duration")
 }
 func init() { proto.RegisterFile("google/protobuf/duration.proto", fileDescriptor_23597b2ebd7ac6c5) }
 var fileDescriptor_23597b2ebd7ac6c5 = []byte{
 	// 190 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
 	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0x29, 0x2d, 0x4a,
 	0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0x56,
 	0x5c, 0x1c, 0x2e, 0x50, 0x25, 0x42, 0x12, 0x5c, 0xec, 0xc5, 0xa9, 0xc9, 0xf9, 0x79, 0x29, 0xc5,
 	0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x30, 0xae, 0x90, 0x08, 0x17, 0x6b, 0x5e, 0x62, 0x5e,
 	0x7e, 0xb1, 0x04, 0x93, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x84, 0xe3, 0x54, 0xc3, 0x25, 0x9c, 0x9c,
 	0x9f, 0xab, 0x87, 0x66, 0xa4, 0x13, 0x2f, 0xcc, 0xc0, 0x00, 0x90, 0x48, 0x00, 0x63, 0x94, 0x56,
 	0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x7a, 0x7e, 0x4e, 0x62, 0x5e,
 	0x3a, 0xc2, 0x7d, 0x05, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x70, 0x67, 0xfe, 0x60, 0x64, 0x5c, 0xc4,
 	0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e, 0x00, 0x54, 0xa9, 0x5e, 0x78,
 	0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b, 0x12, 0x1b, 0xd8, 0x0c, 0x63,
 	0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x84, 0x30, 0xff, 0xf3, 0x00, 0x00, 0x00,
 }
--- a/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
@@ -0,0 +1,117 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // 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.
 syntax = "proto3";
 package google.protobuf;
 option csharp_namespace = "Google.Protobuf.WellKnownTypes";
 option cc_enable_arenas = true;
 option go_package = "github.com/golang/protobuf/ptypes/duration";
 option java_package = "com.google.protobuf";
 option java_outer_classname = "DurationProto";
 option java_multiple_files = true;
 option objc_class_prefix = "GPB";
 // A Duration represents a signed, fixed-length span of time represented
 // as a count of seconds and fractions of seconds at nanosecond
 // resolution. It is independent of any calendar and concepts like "day"
 // or "month". It is related to Timestamp in that the difference between
 // two Timestamp values is a Duration and it can be added or subtracted
 // from a Timestamp. Range is approximately +-10,000 years.
 //
 // # Examples
 //
 // Example 1: Compute Duration from two Timestamps in pseudo code.
 //
 //     Timestamp start = ...;
 //     Timestamp end = ...;
 //     Duration duration = ...;
 //
 //     duration.seconds = end.seconds - start.seconds;
 //     duration.nanos = end.nanos - start.nanos;
 //
 //     if (duration.seconds < 0 && duration.nanos > 0) {
 //       duration.seconds += 1;
 //       duration.nanos -= 1000000000;
 //     } else if (durations.seconds > 0 && duration.nanos < 0) {
 //       duration.seconds -= 1;
 //       duration.nanos += 1000000000;
 //     }
 //
 // Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
 //
 //     Timestamp start = ...;
 //     Duration duration = ...;
 //     Timestamp end = ...;
 //
 //     end.seconds = start.seconds + duration.seconds;
 //     end.nanos = start.nanos + duration.nanos;
 //
 //     if (end.nanos < 0) {
 //       end.seconds -= 1;
 //       end.nanos += 1000000000;
 //     } else if (end.nanos >= 1000000000) {
 //       end.seconds += 1;
 //       end.nanos -= 1000000000;
 //     }
 //
 // Example 3: Compute Duration from datetime.timedelta in Python.
 //
 //     td = datetime.timedelta(days=3, minutes=10)
 //     duration = Duration()
 //     duration.FromTimedelta(td)
 //
 // # JSON Mapping
 //
 // In JSON format, the Duration type is encoded as a string rather than an
 // object, where the string ends in the suffix "s" (indicating seconds) and
 // is preceded by the number of seconds, with nanoseconds expressed as
 // fractional seconds. For example, 3 seconds with 0 nanoseconds should be
 // encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
 // be expressed in JSON format as "3.000000001s", and 3 seconds and 1
 // microsecond should be expressed in JSON format as "3.000001s".
 //
 //
 message Duration {
  // Signed seconds of the span of time. Must be from -315,576,000,000
  // to +315,576,000,000 inclusive. Note: these bounds are computed from:
  // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
  int64 seconds = 1;
  // Signed fractions of a second at nanosecond resolution of the span
  // of time. Durations less than one second are represented with a 0
  // `seconds` field and a positive or negative `nanos` field. For durations
  // of one second or more, a non-zero value for the `nanos` field must be
  // of the same sign as the `seconds` field. Must be from -999,999,999
  // to +999,999,999 inclusive.
  int32 nanos = 2;
 }
--- a/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
@@ -0,0 +1,83 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: google/protobuf/empty.proto
 package empty
 import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	math "math"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 // A generic empty message that you can re-use to avoid defining duplicated
 // empty messages in your APIs. A typical example is to use it as the request
 // or the response type of an API method. For instance:
 //
 //     service Foo {
 //       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
 //     }
 //
 // The JSON representation for `Empty` is empty JSON object `{}`.
 type Empty struct {
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
 }
 func (m *Empty) Reset()         { *m = Empty{} }
 func (m *Empty) String() string { return proto.CompactTextString(m) }
 func (*Empty) ProtoMessage()    {}
 func (*Empty) Descriptor() ([]byte, []int) {
 	return fileDescriptor_900544acb223d5b8, []int{0}
 }
 func (*Empty) XXX_WellKnownType() string { return "Empty" }
 func (m *Empty) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Empty.Unmarshal(m, b)
 }
 func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
 }
 func (m *Empty) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Empty.Merge(m, src)
 }
 func (m *Empty) XXX_Size() int {
 	return xxx_messageInfo_Empty.Size(m)
 }
 func (m *Empty) XXX_DiscardUnknown() {
 	xxx_messageInfo_Empty.DiscardUnknown(m)
 }
 var xxx_messageInfo_Empty proto.InternalMessageInfo
 func init() {
 	proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
 }
 func init() { proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_900544acb223d5b8) }
 var fileDescriptor_900544acb223d5b8 = []byte{
 	// 148 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xcf, 0xcf, 0x4f,
 	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcd, 0x2d, 0x28,
 	0xa9, 0xd4, 0x03, 0x73, 0x85, 0xf8, 0x21, 0x92, 0x7a, 0x30, 0x49, 0x25, 0x76, 0x2e, 0x56, 0x57,
 	0x90, 0xbc, 0x53, 0x19, 0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x9a, 0xbc, 0x13, 0x17, 0x58, 0x36,
 	0x00, 0xc4, 0x0d, 0x60, 0x8c, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
 	0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0x47, 0x58, 0x53, 0x50, 0x52, 0x59, 0x90, 0x5a, 0x0c,
 	0xb1, 0xed, 0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10,
 	0x13, 0x03, 0xa0, 0xea, 0xf4, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40,
 	0xea, 0x93, 0xd8, 0xc0, 0x06, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x64, 0xd4, 0xb3, 0xa6,
 	0xb7, 0x00, 0x00, 0x00,
 }
--- a/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto
+++ b/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto
@@ -0,0 +1,52 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // 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.
 syntax = "proto3";
 package google.protobuf;
 option csharp_namespace = "Google.Protobuf.WellKnownTypes";
 option go_package = "github.com/golang/protobuf/ptypes/empty";
 option java_package = "com.google.protobuf";
 option java_outer_classname = "EmptyProto";
 option java_multiple_files = true;
 option objc_class_prefix = "GPB";
 option cc_enable_arenas = true;
 // A generic empty message that you can re-use to avoid defining duplicated
 // empty messages in your APIs. A typical example is to use it as the request
 // or the response type of an API method. For instance:
 //
 //     service Foo {
 //       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
 //     }
 //
 // The JSON representation for `Empty` is empty JSON object `{}`.
 message Empty {}
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
@@ -0,0 +1,134 @@
 // Go support for Protocol Buffers - Google's data interchange format
 //
 // Copyright 2016 The Go Authors.  All rights reserved.
 // https://github.com/golang/protobuf
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package ptypes
 // This file implements operations on google.protobuf.Timestamp.
 import (
 	"errors"
 	"fmt"
 	"time"
 	tspb "github.com/golang/protobuf/ptypes/timestamp"
 )
 const (
 	// Seconds field of the earliest valid Timestamp.
 	// This is time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
 	minValidSeconds = -62135596800
 	// Seconds field just after the latest valid Timestamp.
 	// This is time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
 	maxValidSeconds = 253402300800
 )
 // validateTimestamp determines whether a Timestamp is valid.
 // A valid timestamp represents a time in the range
 // [0001-01-01, 10000-01-01) and has a Nanos field
 // in the range [0, 1e9).
 //
 // If the Timestamp is valid, validateTimestamp returns nil.
 // Otherwise, it returns an error that describes
 // the problem.
 //
 // Every valid Timestamp can be represented by a time.Time, but the converse is not true.
 func validateTimestamp(ts *tspb.Timestamp) error {
 	if ts == nil {
 		return errors.New("timestamp: nil Timestamp")
 	}
 	if ts.Seconds < minValidSeconds {
 		return fmt.Errorf("timestamp: %v before 0001-01-01", ts)
 	}
 	if ts.Seconds >= maxValidSeconds {
 		return fmt.Errorf("timestamp: %v after 10000-01-01", ts)
 	}
 	if ts.Nanos < 0 || ts.Nanos >= 1e9 {
 		return fmt.Errorf("timestamp: %v: nanos not in range [0, 1e9)", ts)
 	}
 	return nil
 }
 // Timestamp converts a google.protobuf.Timestamp proto to a time.Time.
 // It returns an error if the argument is invalid.
 //
 // Unlike most Go functions, if Timestamp returns an error, the first return value
 // is not the zero time.Time. Instead, it is the value obtained from the
 // time.Unix function when passed the contents of the Timestamp, in the UTC
 // locale. This may or may not be a meaningful time; many invalid Timestamps
 // do map to valid time.Times.
 //
 // A nil Timestamp returns an error. The first return value in that case is
 // undefined.
 func Timestamp(ts *tspb.Timestamp) (time.Time, error) {
 	// Don't return the zero value on error, because corresponds to a valid
 	// timestamp. Instead return whatever time.Unix gives us.
 	var t time.Time
 	if ts == nil {
 		t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
 	} else {
 		t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
 	}
 	return t, validateTimestamp(ts)
 }
 // TimestampNow returns a google.protobuf.Timestamp for the current time.
 func TimestampNow() *tspb.Timestamp {
 	ts, err := TimestampProto(time.Now())
 	if err != nil {
 		panic("ptypes: time.Now() out of Timestamp range")
 	}
 	return ts
 }
 // TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
 // It returns an error if the resulting Timestamp is invalid.
 func TimestampProto(t time.Time) (*tspb.Timestamp, error) {
 	seconds := t.Unix()
 	nanos := int32(t.Sub(time.Unix(seconds, 0)))
 	ts := &tspb.Timestamp{
 		Seconds: seconds,
 		Nanos:   nanos,
 	}
 	if err := validateTimestamp(ts); err != nil {
 		return nil, err
 	}
 	return ts, nil
 }
 // TimestampString returns the RFC 3339 string for valid Timestamps. For invalid
 // Timestamps, it returns an error message in parentheses.
 func TimestampString(ts *tspb.Timestamp) string {
 	t, err := Timestamp(ts)
 	if err != nil {
 		return fmt.Sprintf("(%v)", err)
 	}
 	return t.Format(time.RFC3339Nano)
 }
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
@@ -0,0 +1,177 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: google/protobuf/timestamp.proto
 package timestamp
 import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	math "math"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 // A Timestamp represents a point in time independent of any time zone
 // or calendar, represented as seconds and fractions of seconds at
 // nanosecond resolution in UTC Epoch time. It is encoded using the
 // Proleptic Gregorian Calendar which extends the Gregorian calendar
 // backwards to year one. It is encoded assuming all minutes are 60
 // seconds long, i.e. leap seconds are "smeared" so that no leap second
 // table is needed for interpretation. Range is from
 // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
 // By restricting to that range, we ensure that we can convert to
 // and from  RFC 3339 date strings.
 // See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
 //
 // # Examples
 //
 // Example 1: Compute Timestamp from POSIX `time()`.
 //
 //     Timestamp timestamp;
 //     timestamp.set_seconds(time(NULL));
 //     timestamp.set_nanos(0);
 //
 // Example 2: Compute Timestamp from POSIX `gettimeofday()`.
 //
 //     struct timeval tv;
 //     gettimeofday(&tv, NULL);
 //
 //     Timestamp timestamp;
 //     timestamp.set_seconds(tv.tv_sec);
 //     timestamp.set_nanos(tv.tv_usec * 1000);
 //
 // Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
 //
 //     FILETIME ft;
 //     GetSystemTimeAsFileTime(&ft);
 //     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
 //
 //     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
 //     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
 //     Timestamp timestamp;
 //     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
 //     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
 //
 // Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
 //
 //     long millis = System.currentTimeMillis();
 //
 //     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
 //         .setNanos((int) ((millis % 1000) * 1000000)).build();
 //
 //
 // Example 5: Compute Timestamp from current time in Python.
 //
 //     timestamp = Timestamp()
 //     timestamp.GetCurrentTime()
 //
 // # JSON Mapping
 //
 // In JSON format, the Timestamp type is encoded as a string in the
 // [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
 // format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
 // where {year} is always expressed using four digits while {month}, {day},
 // {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
 // seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
 // are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
 // is required, though only UTC (as indicated by "Z") is presently supported.
 //
 // For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
 // 01:30 UTC on January 15, 2017.
 //
 // In JavaScript, one can convert a Date object to this format using the
 // standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
 // method. In Python, a standard `datetime.datetime` object can be converted
 // to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
 // with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
 // can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
 // http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--)
 // to obtain a formatter capable of generating timestamps in this format.
 //
 //
 type Timestamp struct {
 	// Represents seconds of UTC time since Unix epoch
 	// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
 	// 9999-12-31T23:59:59Z inclusive.
 	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
 	// Non-negative fractions of a second at nanosecond resolution. Negative
 	// second values with fractions must still have non-negative nanos values
 	// that count forward in time. Must be from 0 to 999,999,999
 	// inclusive.
 	Nanos                int32    `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
 }
 func (m *Timestamp) Reset()         { *m = Timestamp{} }
 func (m *Timestamp) String() string { return proto.CompactTextString(m) }
 func (*Timestamp) ProtoMessage()    {}
 func (*Timestamp) Descriptor() ([]byte, []int) {
 	return fileDescriptor_292007bbfe81227e, []int{0}
 }
 func (*Timestamp) XXX_WellKnownType() string { return "Timestamp" }
 func (m *Timestamp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Timestamp.Unmarshal(m, b)
 }
 func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic)
 }
 func (m *Timestamp) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Timestamp.Merge(m, src)
 }
 func (m *Timestamp) XXX_Size() int {
 	return xxx_messageInfo_Timestamp.Size(m)
 }
 func (m *Timestamp) XXX_DiscardUnknown() {
 	xxx_messageInfo_Timestamp.DiscardUnknown(m)
 }
 var xxx_messageInfo_Timestamp proto.InternalMessageInfo
 func (m *Timestamp) GetSeconds() int64 {
 	if m != nil {
 		return m.Seconds
 	}
 	return 0
 }
 func (m *Timestamp) GetNanos() int32 {
 	if m != nil {
 		return m.Nanos
 	}
 	return 0
 }
 func init() {
 	proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
 }
 func init() { proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor_292007bbfe81227e) }
 var fileDescriptor_292007bbfe81227e = []byte{
 	// 191 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f,
 	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d,
 	0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0xd0, 0x03, 0x0b, 0x09, 0xf1, 0x43, 0x14, 0xe8, 0xc1, 0x14, 0x28,
 	0x59, 0x73, 0x71, 0x86, 0xc0, 0xd4, 0x08, 0x49, 0x70, 0xb1, 0x17, 0xa7, 0x26, 0xe7, 0xe7, 0xa5,
 	0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x30, 0x07, 0xc1, 0xb8, 0x42, 0x22, 0x5c, 0xac, 0x79, 0x89,
 	0x79, 0xf9, 0xc5, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x10, 0x8e, 0x53, 0x1d, 0x97, 0x70,
 	0x72, 0x7e, 0xae, 0x1e, 0x9a, 0x99, 0x4e, 0x7c, 0x70, 0x13, 0x03, 0x40, 0x42, 0x01, 0x8c, 0x51,
 	0xda, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xe9, 0xf9, 0x39, 0x89,
 	0x79, 0xe9, 0x08, 0x27, 0x16, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x23, 0x5c, 0xfa, 0x83, 0x91, 0x71,
 	0x11, 0x13, 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, 0xc9, 0x01, 0x50, 0xb5, 0x7a,
 	0xe1, 0xa9, 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, 0x3d, 0x49, 0x6c, 0x60, 0x43,
 	0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x77, 0x4a, 0x07, 0xf7, 0x00, 0x00, 0x00,
 }
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
@@ -0,0 +1,133 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // 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.
 syntax = "proto3";
 package google.protobuf;
 option csharp_namespace = "Google.Protobuf.WellKnownTypes";
 option cc_enable_arenas = true;
 option go_package = "github.com/golang/protobuf/ptypes/timestamp";
 option java_package = "com.google.protobuf";
 option java_outer_classname = "TimestampProto";
 option java_multiple_files = true;
 option objc_class_prefix = "GPB";
 // A Timestamp represents a point in time independent of any time zone
 // or calendar, represented as seconds and fractions of seconds at
 // nanosecond resolution in UTC Epoch time. It is encoded using the
 // Proleptic Gregorian Calendar which extends the Gregorian calendar
 // backwards to year one. It is encoded assuming all minutes are 60
 // seconds long, i.e. leap seconds are "smeared" so that no leap second
 // table is needed for interpretation. Range is from
 // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
 // By restricting to that range, we ensure that we can convert to
 // and from  RFC 3339 date strings.
 // See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
 //
 // # Examples
 //
 // Example 1: Compute Timestamp from POSIX `time()`.
 //
 //     Timestamp timestamp;
 //     timestamp.set_seconds(time(NULL));
 //     timestamp.set_nanos(0);
 //
 // Example 2: Compute Timestamp from POSIX `gettimeofday()`.
 //
 //     struct timeval tv;
 //     gettimeofday(&tv, NULL);
 //
 //     Timestamp timestamp;
 //     timestamp.set_seconds(tv.tv_sec);
 //     timestamp.set_nanos(tv.tv_usec * 1000);
 //
 // Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
 //
 //     FILETIME ft;
 //     GetSystemTimeAsFileTime(&ft);
 //     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
 //
 //     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
 //     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
 //     Timestamp timestamp;
 //     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
 //     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
 //
 // Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
 //
 //     long millis = System.currentTimeMillis();
 //
 //     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
 //         .setNanos((int) ((millis % 1000) * 1000000)).build();
 //
 //
 // Example 5: Compute Timestamp from current time in Python.
 //
 //     timestamp = Timestamp()
 //     timestamp.GetCurrentTime()
 //
 // # JSON Mapping
 //
 // In JSON format, the Timestamp type is encoded as a string in the
 // [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
 // format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
 // where {year} is always expressed using four digits while {month}, {day},
 // {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
 // seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
 // are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
 // is required, though only UTC (as indicated by "Z") is presently supported.
 //
 // For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
 // 01:30 UTC on January 15, 2017.
 //
 // In JavaScript, one can convert a Date object to this format using the
 // standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
 // method. In Python, a standard `datetime.datetime` object can be converted
 // to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
 // with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
 // can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
 // http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--)
 // to obtain a formatter capable of generating timestamps in this format.
 //
 //
 message Timestamp {
  // Represents seconds of UTC time since Unix epoch
  // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
  // 9999-12-31T23:59:59Z inclusive.
  int64 seconds = 1;
  // Non-negative fractions of a second at nanosecond resolution. Negative
  // second values with fractions must still have non-negative nanos values
  // that count forward in time. Must be from 0 to 999,999,999
  // inclusive.
  int32 nanos = 2;
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mayuresh Gaitonde	a8fd79c0e1	Add app source, add vendoring and module support	2019-10-16 15:57:55 -07:00
mayuresh82	b49447a374	Merge pull request #1 from mayuresh82/fix_gw Add a fix for gw ip	2019-09-12 14:44:58 -07:00
Mayuresh Gaitonde	b0dbda04c9	Add a fix for gw ip	2019-09-12 14:44:21 -07:00
Mayuresh Gaitonde	e15172111e	fix non local peer and add multihop	2018-11-26 16:44:39 -08:00
Mayuresh Gaitonde	b641eb979e	fix	2018-11-21 11:25:34 -08:00
Mayuresh Gaitonde	6e923a84fa	bugfix	2018-11-21 10:57:46 -08:00
Mayuresh Gaitonde	2a3593aade	add debug logs for bgp	2018-11-21 10:37:11 -08:00
Mayuresh Gaitonde	6a184933d1	Fix consul helthcheck	2018-11-20 18:16:44 -08:00