MVP, no mod tools or anything but it works

vendor/github.com/GeertJohan/go.rice/AUTHORS

@@ -0,0 +1,4 @@
+Geert-Johan Riemer <geertjohan@geertjohan.net>
+Paul Maddox <paul.maddox@gmail.com>
+Vincent Petithory <vincent.petithory@gmail.com>
+

vendor/github.com/GeertJohan/go.rice/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013, Geert-Johan Riemer
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/GeertJohan/go.rice/README.md

@@ -0,0 +1,151 @@
+## go.rice
+
+[![Wercker](https://img.shields.io/wercker/ci/54c7af4dcc09f9963725bb25.svg?style=flat-square)](https://app.wercker.com/#applications/54c7af4dcc09f9963725bb25)
+[![Godoc](https://img.shields.io/badge/godoc-go.rice-blue.svg?style=flat-square)](https://godoc.org/github.com/GeertJohan/go.rice)
+
+go.rice is a [Go](http://golang.org) package that makes working with resources such as html,js,css,images and templates very easy. During development `go.rice` will load required files directly from disk. Upon deployment it is easy to add all resource files to a executable using the `rice` tool, without changing the source code for your package. go.rice provides several methods to add resources to a binary.
+
+### What does it do?
+The first thing go.rice does is finding the correct absolute path for your resource files. Say you are executing go binary in your home directory, but your `html-files` are located in `$GOPATH/src/yourApplication/html-files`. `go.rice` will lookup the correct path for that directory (relative to the location of yourApplication). The only thing you have to do is include the resources using `rice.FindBox("html-files")`.
+
+This only works when the source is available to the machine executing the binary. Which is always the case when the binary was installed with `go get` or `go install`. It might occur that you wish to simply provide a binary, without source. The `rice` tool analyses source code and finds call's to `rice.FindBox(..)` and adds the required directories to the executable binary. There are several methods to add these resources. You can 'embed' by generating go source code, or append the resource to the executable as zip file. In both cases `go.rice` will detect the embedded or appended resources and load those, instead of looking up files from disk.
+
+### Installation
+
+Use `go get` to install the package the `rice` tool.
+```
+go get github.com/GeertJohan/go.rice
+go get github.com/GeertJohan/go.rice/rice
+```
+
+### Package usage
+
+Import the package: `import "github.com/GeertJohan/go.rice"`
+
+**Serving a static content folder over HTTP with a rice Box**
+```go
+http.Handle("/", http.FileServer(rice.MustFindBox("http-files").HTTPBox()))
+http.ListenAndServe(":8080", nil)
+```
+
+**Service a static content folder over HTTP at a non-root location**
+```go
+box := rice.MustFindBox("cssfiles")
+cssFileServer := http.StripPrefix("/css/", http.FileServer(box.HTTPBox()))
+http.Handle("/css/", cssFileServer)
+http.ListenAndServe(":8080", nil)
+```
+
+Note the *trailing slash* in `/css/` in both the call to
+`http.StripPrefix` and `http.Handle`.
+
+**Loading a template**
+```go
+// find a rice.Box
+templateBox, err := rice.FindBox("example-templates")
+if err != nil {
+	log.Fatal(err)
+}
+// get file contents as string
+templateString, err := templateBox.String("message.tmpl")
+if err != nil {
+	log.Fatal(err)
+}
+// parse and execute the template
+tmplMessage, err := template.New("message").Parse(templateString)
+if err != nil {
+	log.Fatal(err)
+}
+tmplMessage.Execute(os.Stdout, map[string]string{"Message": "Hello, world!"})
+
+```
+
+Never call `FindBox()` or `MustFindBox()` from an `init()` function, as the boxes might have not been loaded at that time.
+
+### Tool usage
+The `rice` tool lets you add the resources to a binary executable so the files are not loaded from the filesystem anymore. This creates a 'standalone' executable. There are several ways to add the resources to a binary, each has pro's and con's but all will work without requiring changes to the way you load the resources.
+
+#### embed-go
+**Embed resources by generating Go source code**
+
+This method must be executed before building. It generates a single Go source file called *rice-box.go* for each package, that is compiled by the go compiler into the binary.
+
+The downside with this option is that the generated go source files can become very large, which will slow down compilation and require lots of memory to compile.
+
+Execute the following commands:
+```
+rice embed-go
+go build
+```
+
+*A Note on Symbolic Links*: `embed-go` uses the `os.Walk` function
+from the standard library.  The `os.Walk` function does **not** follow
+symbolic links.  So, when creating a box, be aware that any symbolic
+links inside your box's directory will not be followed.  **However**,
+if the box itself is a symbolic link, its actual location will be
+resolved first and then walked.  In summary, if your box location is a
+symbolic link, it will be followed but none of the symbolic links in
+the box will be followed.
+
+#### embed-syso
+**Embed resources by generating a coff .syso file and some .go source code**
+
+** This method is experimental and should not be used for production systems just yet **
+
+This method must be executed before building. It generates a COFF .syso file and Go source file that are compiled by the go compiler into the binary.
+
+Execute the following commands:
+```
+rice embed-syso
+go build
+```
+
+#### append
+**Append resources to executable as zip file**
+
+This method changes an already built executable. It appends the resources as zip file to the binary. It makes compilation a lot faster and can be used with large resource files.
+
+Downsides for appending are that it requires `zip` to be installed and does not provide a working Seek method.
+
+Run the following commands to create a standalone executable.
+```
+go build -o example
+rice append --exec example
+```
+
+**Note: requires zip command to be installed**
+
+On windows, install zip from http://gnuwin32.sourceforge.net/packages/zip.htm or cygwin/msys toolsets.
+
+#### Help information
+Run `rice -h` for information about all options.
+
+You can run the -h option for each sub-command, e.g. `rice append -h`.
+
+### Order of precedence
+When opening a new box, the rice package tries to locate the resources in the following order:
+
+ - embedded in generated go source
+ - appended as zip
+ - 'live' from filesystem
+
+
+### License
+This project is licensed under a Simplified BSD license. Please read the [LICENSE file][license].
+
+### TODO & Development
+This package is not completed yet. Though it already provides working embedding, some important featuers are still missing.
+ - implement Readdir() correctly on virtualDir
+ - in-code TODO's
+ - find boxes in imported packages
+
+Less important stuff:
+ - idea, os/arch dependent embeds. rice checks if embedding file has _os_arch or build flags. If box is not requested by file without buildflags, then the buildflags are applied to the embed file.
+
+### Package documentation
+
+You will find package documentation at [godoc.org/github.com/GeertJohan/go.rice][godoc].
+
+
+ [license]: https://github.com/GeertJohan/go.rice/blob/master/LICENSE
+ [godoc]: http://godoc.org/github.com/GeertJohan/go.rice

vendor/github.com/GeertJohan/go.rice/appended.go

@@ -0,0 +1,138 @@
+package rice
+
+import (
+	"archive/zip"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/daaku/go.zipexe"
+	"github.com/kardianos/osext"
+)
+
+// appendedBox defines an appended box
+type appendedBox struct {
+	Name  string                   // box name
+	Files map[string]*appendedFile // appended files (*zip.File) by full path
+}
+
+type appendedFile struct {
+	zipFile  *zip.File
+	dir      bool
+	dirInfo  *appendedDirInfo
+	children []*appendedFile
+	content  []byte
+}
+
+// appendedBoxes is a public register of appendes boxes
+var appendedBoxes = make(map[string]*appendedBox)
+
+func init() {
+	// find if exec is appended
+	thisFile, err := osext.Executable()
+	if err != nil {
+		return // not appended or cant find self executable
+	}
+	closer, rd, err := zipexe.OpenCloser(thisFile)
+	if err != nil {
+		return // not appended
+	}
+	defer closer.Close()
+
+	for _, f := range rd.File {
+		// get box and file name from f.Name
+		fileParts := strings.SplitN(strings.TrimLeft(filepath.ToSlash(f.Name), "/"), "/", 2)
+		boxName := fileParts[0]
+		var fileName string
+		if len(fileParts) > 1 {
+			fileName = fileParts[1]
+		}
+
+		// find box or create new one if doesn't exist
+		box := appendedBoxes[boxName]
+		if box == nil {
+			box = &appendedBox{
+				Name:  boxName,
+				Files: make(map[string]*appendedFile),
+			}
+			appendedBoxes[boxName] = box
+		}
+
+		// create and add file to box
+		af := &appendedFile{
+			zipFile: f,
+		}
+		if f.Comment == "dir" {
+			af.dir = true
+			af.dirInfo = &appendedDirInfo{
+				name: filepath.Base(af.zipFile.Name),
+				//++ TODO: use zip modtime when that is set correctly: af.zipFile.ModTime()
+				time: time.Now(),
+			}
+		} else {
+			// this is a file, we need it's contents so we can create a bytes.Reader when the file is opened
+			// make a new byteslice
+			af.content = make([]byte, af.zipFile.FileInfo().Size())
+			// ignore reading empty files from zip (empty file still is a valid file to be read though!)
+			if len(af.content) > 0 {
+				// open io.ReadCloser
+				rc, err := af.zipFile.Open()
+				if err != nil {
+					af.content = nil // this will cause an error when the file is being opened or seeked (which is good)
+					// TODO: it's quite blunt to just log this stuff. but this is in init, so rice.Debug can't be changed yet..
+					log.Printf("error opening appended file %s: %v", af.zipFile.Name, err)
+				} else {
+					_, err = rc.Read(af.content)
+					rc.Close()
+					if err != nil {
+						af.content = nil // this will cause an error when the file is being opened or seeked (which is good)
+						// TODO: it's quite blunt to just log this stuff. but this is in init, so rice.Debug can't be changed yet..
+						log.Printf("error reading data for appended file %s: %v", af.zipFile.Name, err)
+					}
+				}
+			}
+		}
+
+		// add appendedFile to box file list
+		box.Files[fileName] = af
+
+		// add to parent dir (if any)
+		dirName := filepath.Dir(fileName)
+		if dirName == "." {
+			dirName = ""
+		}
+		if fileName != "" { // don't make box root dir a child of itself
+			if dir := box.Files[dirName]; dir != nil {
+				dir.children = append(dir.children, af)
+			}
+		}
+	}
+}
+
+// implements os.FileInfo.
+// used for Readdir()
+type appendedDirInfo struct {
+	name string
+	time time.Time
+}
+
+func (adi *appendedDirInfo) Name() string {
+	return adi.name
+}
+func (adi *appendedDirInfo) Size() int64 {
+	return 0
+}
+func (adi *appendedDirInfo) Mode() os.FileMode {
+	return os.ModeDir
+}
+func (adi *appendedDirInfo) ModTime() time.Time {
+	return adi.time
+}
+func (adi *appendedDirInfo) IsDir() bool {
+	return true
+}
+func (adi *appendedDirInfo) Sys() interface{} {
+	return nil
+}

vendor/github.com/GeertJohan/go.rice/box.go

@@ -0,0 +1,337 @@
+package rice
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/GeertJohan/go.rice/embedded"
+)
+
+// Box abstracts a directory for resources/files.
+// It can either load files from disk, or from embedded code (when `rice --embed` was ran).
+type Box struct {
+	name         string
+	absolutePath string
+	embed        *embedded.EmbeddedBox
+	appendd      *appendedBox
+}
+
+var defaultLocateOrder = []LocateMethod{LocateEmbedded, LocateAppended, LocateFS}
+
+func findBox(name string, order []LocateMethod) (*Box, error) {
+	b := &Box{name: name}
+
+	// no support for absolute paths since gopath can be different on different machines.
+	// therefore, required box must be located relative to package requiring it.
+	if filepath.IsAbs(name) {
+		return nil, errors.New("given name/path is absolute")
+	}
+
+	var err error
+	for _, method := range order {
+		switch method {
+		case LocateEmbedded:
+			if embed := embedded.EmbeddedBoxes[name]; embed != nil {
+				b.embed = embed
+				return b, nil
+			}
+
+		case LocateAppended:
+			appendedBoxName := strings.Replace(name, `/`, `-`, -1)
+			if appendd := appendedBoxes[appendedBoxName]; appendd != nil {
+				b.appendd = appendd
+				return b, nil
+			}
+
+		case LocateFS:
+			// resolve absolute directory path
+			err := b.resolveAbsolutePathFromCaller()
+			if err != nil {
+				continue
+			}
+			// check if absolutePath exists on filesystem
+			info, err := os.Stat(b.absolutePath)
+			if err != nil {
+				continue
+			}
+			// check if absolutePath is actually a directory
+			if !info.IsDir() {
+				err = errors.New("given name/path is not a directory")
+				continue
+			}
+			return b, nil
+		case LocateWorkingDirectory:
+			// resolve absolute directory path
+			err := b.resolveAbsolutePathFromWorkingDirectory()
+			if err != nil {
+				continue
+			}
+			// check if absolutePath exists on filesystem
+			info, err := os.Stat(b.absolutePath)
+			if err != nil {
+				continue
+			}
+			// check if absolutePath is actually a directory
+			if !info.IsDir() {
+				err = errors.New("given name/path is not a directory")
+				continue
+			}
+			return b, nil
+		}
+	}
+
+	if err == nil {
+		err = fmt.Errorf("could not locate box %q", name)
+	}
+
+	return nil, err
+}
+
+// FindBox returns a Box instance for given name.
+// When the given name is a relative path, it's base path will be the calling pkg/cmd's source root.
+// When the given name is absolute, it's absolute. derp.
+// Make sure the path doesn't contain any sensitive information as it might be placed into generated go source (embedded).
+func FindBox(name string) (*Box, error) {
+	return findBox(name, defaultLocateOrder)
+}
+
+// MustFindBox returns a Box instance for given name, like FindBox does.
+// It does not return an error, instead it panics when an error occurs.
+func MustFindBox(name string) *Box {
+	box, err := findBox(name, defaultLocateOrder)
+	if err != nil {
+		panic(err)
+	}
+	return box
+}
+
+// This is injected as a mutable function literal so that we can mock it out in
+// tests and return a fixed test file.
+var resolveAbsolutePathFromCaller = func(name string, nStackFrames int) (string, error) {
+	_, callingGoFile, _, ok := runtime.Caller(nStackFrames)
+	if !ok {
+		return "", errors.New("couldn't find caller on stack")
+	}
+
+	// resolve to proper path
+	pkgDir := filepath.Dir(callingGoFile)
+	// fix for go cover
+	const coverPath = "_test/_obj_test"
+	if !filepath.IsAbs(pkgDir) {
+		if i := strings.Index(pkgDir, coverPath); i >= 0 {
+			pkgDir = pkgDir[:i] + pkgDir[i+len(coverPath):]            // remove coverPath
+			pkgDir = filepath.Join(os.Getenv("GOPATH"), "src", pkgDir) // make absolute
+		}
+	}
+	return filepath.Join(pkgDir, name), nil
+}
+
+func (b *Box) resolveAbsolutePathFromCaller() error {
+	path, err := resolveAbsolutePathFromCaller(b.name, 4)
+	if err != nil {
+		return err
+	}
+	b.absolutePath = path
+	return nil
+
+}
+
+func (b *Box) resolveAbsolutePathFromWorkingDirectory() error {
+	path, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	b.absolutePath = filepath.Join(path, b.name)
+	return nil
+}
+
+// IsEmbedded indicates wether this box was embedded into the application
+func (b *Box) IsEmbedded() bool {
+	return b.embed != nil
+}
+
+// IsAppended indicates wether this box was appended to the application
+func (b *Box) IsAppended() bool {
+	return b.appendd != nil
+}
+
+// Time returns how actual the box is.
+// When the box is embedded, it's value is saved in the embedding code.
+// When the box is live, this methods returns time.Now()
+func (b *Box) Time() time.Time {
+	if b.IsEmbedded() {
+		return b.embed.Time
+	}
+
+	//++ TODO: return time for appended box
+
+	return time.Now()
+}
+
+// Open opens a File from the box
+// If there is an error, it will be of type *os.PathError.
+func (b *Box) Open(name string) (*File, error) {
+	if Debug {
+		fmt.Printf("Open(%s)\n", name)
+	}
+
+	if b.IsEmbedded() {
+		if Debug {
+			fmt.Println("Box is embedded")
+		}
+
+		// trim prefix (paths are relative to box)
+		name = strings.TrimLeft(name, "/")
+		if Debug {
+			fmt.Printf("Trying %s\n", name)
+		}
+
+		// search for file
+		ef := b.embed.Files[name]
+		if ef == nil {
+			if Debug {
+				fmt.Println("Didn't find file in embed")
+			}
+			// file not found, try dir
+			ed := b.embed.Dirs[name]
+			if ed == nil {
+				if Debug {
+					fmt.Println("Didn't find dir in embed")
+				}
+				// dir not found, error out
+				return nil, &os.PathError{
+					Op:   "open",
+					Path: name,
+					Err:  os.ErrNotExist,
+				}
+			}
+			if Debug {
+				fmt.Println("Found dir. Returning virtual dir")
+			}
+			vd := newVirtualDir(ed)
+			return &File{virtualD: vd}, nil
+		}
+
+		// box is embedded
+		if Debug {
+			fmt.Println("Found file. Returning virtual file")
+		}
+		vf := newVirtualFile(ef)
+		return &File{virtualF: vf}, nil
+	}
+
+	if b.IsAppended() {
+		// trim prefix (paths are relative to box)
+		name = strings.TrimLeft(name, "/")
+
+		// search for file
+		appendedFile := b.appendd.Files[name]
+		if appendedFile == nil {
+			return nil, &os.PathError{
+				Op:   "open",
+				Path: name,
+				Err:  os.ErrNotExist,
+			}
+		}
+
+		// create new file
+		f := &File{
+			appendedF: appendedFile,
+		}
+
+		// if this file is a directory, we want to be able to read and seek
+		if !appendedFile.dir {
+			// looks like malformed data in zip, error now
+			if appendedFile.content == nil {
+				return nil, &os.PathError{
+					Op:   "open",
+					Path: "name",
+					Err:  errors.New("error reading data from zip file"),
+				}
+			}
+			// create new bytes.Reader
+			f.appendedFileReader = bytes.NewReader(appendedFile.content)
+		}
+
+		// all done
+		return f, nil
+	}
+
+	// perform os open
+	if Debug {
+		fmt.Printf("Using os.Open(%s)", filepath.Join(b.absolutePath, name))
+	}
+	file, err := os.Open(filepath.Join(b.absolutePath, name))
+	if err != nil {
+		return nil, err
+	}
+	return &File{realF: file}, nil
+}
+
+// Bytes returns the content of the file with given name as []byte.
+func (b *Box) Bytes(name string) ([]byte, error) {
+	file, err := b.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	content, err := ioutil.ReadAll(file)
+	if err != nil {
+		return nil, err
+	}
+
+	return content, nil
+}
+
+// MustBytes returns the content of the file with given name as []byte.
+// panic's on error.
+func (b *Box) MustBytes(name string) []byte {
+	bts, err := b.Bytes(name)
+	if err != nil {
+		panic(err)
+	}
+	return bts
+}
+
+// String returns the content of the file with given name as string.
+func (b *Box) String(name string) (string, error) {
+	// check if box is embedded, optimized fast path
+	if b.IsEmbedded() {
+		// find file in embed
+		ef := b.embed.Files[name]
+		if ef == nil {
+			return "", os.ErrNotExist
+		}
+		// return as string
+		return ef.Content, nil
+	}
+
+	bts, err := b.Bytes(name)
+	if err != nil {
+		return "", err
+	}
+	return string(bts), nil
+}
+
+// MustString returns the content of the file with given name as string.
+// panic's on error.
+func (b *Box) MustString(name string) string {
+	str, err := b.String(name)
+	if err != nil {
+		panic(err)
+	}
+	return str
+}
+
+// Name returns the name of the box
+func (b *Box) Name() string {
+	return b.name
+}

vendor/github.com/GeertJohan/go.rice/config.go

@@ -0,0 +1,39 @@
+package rice
+
+// LocateMethod defines how a box is located.
+type LocateMethod int
+
+const (
+	LocateFS               = LocateMethod(iota) // Locate on the filesystem according to package path.
+	LocateAppended                              // Locate boxes appended to the executable.
+	LocateEmbedded                              // Locate embedded boxes.
+	LocateWorkingDirectory                      // Locate on the binary working directory
+)
+
+// Config allows customizing the box lookup behavior.
+type Config struct {
+	// LocateOrder defines the priority order that boxes are searched for. By
+	// default, the package global FindBox searches for embedded boxes first,
+	// then appended boxes, and then finally boxes on the filesystem.  That
+	// search order may be customized by provided the ordered list here. Leaving
+	// out a particular method will omit that from the search space. For
+	// example, []LocateMethod{LocateEmbedded, LocateAppended} will never search
+	// the filesystem for boxes.
+	LocateOrder []LocateMethod
+}
+
+// FindBox searches for boxes using the LocateOrder of the config.
+func (c *Config) FindBox(boxName string) (*Box, error) {
+	return findBox(boxName, c.LocateOrder)
+}
+
+// MustFindBox searches for boxes using the LocateOrder of the config, like
+// FindBox does.  It does not return an error, instead it panics when an error
+// occurs.
+func (c *Config) MustFindBox(boxName string) *Box {
+	box, err := findBox(boxName, c.LocateOrder)
+	if err != nil {
+		panic(err)
+	}
+	return box
+}

vendor/github.com/GeertJohan/go.rice/debug.go

@@ -0,0 +1,4 @@
+package rice
+
+// Debug can be set to true to enable debugging.
+var Debug = false

vendor/github.com/GeertJohan/go.rice/embedded.go

@@ -0,0 +1,90 @@
+package rice
+
+import (
+	"os"
+	"time"
+
+	"github.com/GeertJohan/go.rice/embedded"
+)
+
+// re-type to make exported methods invisible to user (godoc)
+// they're not required for the user
+// embeddedDirInfo implements os.FileInfo
+type embeddedDirInfo embedded.EmbeddedDir
+
+// Name returns the base name of the directory
+// (implementing os.FileInfo)
+func (ed *embeddedDirInfo) Name() string {
+	return ed.Filename
+}
+
+// Size always returns 0
+// (implementing os.FileInfo)
+func (ed *embeddedDirInfo) Size() int64 {
+	return 0
+}
+
+// Mode returns the file mode bits
+// (implementing os.FileInfo)
+func (ed *embeddedDirInfo) Mode() os.FileMode {
+	return os.FileMode(0555 | os.ModeDir) // dr-xr-xr-x
+}
+
+// ModTime returns the modification time
+// (implementing os.FileInfo)
+func (ed *embeddedDirInfo) ModTime() time.Time {
+	return ed.DirModTime
+}
+
+// IsDir returns the abbreviation for Mode().IsDir() (always true)
+// (implementing os.FileInfo)
+func (ed *embeddedDirInfo) IsDir() bool {
+	return true
+}
+
+// Sys returns the underlying data source (always nil)
+// (implementing os.FileInfo)
+func (ed *embeddedDirInfo) Sys() interface{} {
+	return nil
+}
+
+// re-type to make exported methods invisible to user (godoc)
+// they're not required for the user
+// embeddedFileInfo implements os.FileInfo
+type embeddedFileInfo embedded.EmbeddedFile
+
+// Name returns the base name of the file
+// (implementing os.FileInfo)
+func (ef *embeddedFileInfo) Name() string {
+	return ef.Filename
+}
+
+// Size returns the length in bytes for regular files; system-dependent for others
+// (implementing os.FileInfo)
+func (ef *embeddedFileInfo) Size() int64 {
+	return int64(len(ef.Content))
+}
+
+// Mode returns the file mode bits
+// (implementing os.FileInfo)
+func (ef *embeddedFileInfo) Mode() os.FileMode {
+	return os.FileMode(0555) // r-xr-xr-x
+}
+
+// ModTime returns the modification time
+// (implementing os.FileInfo)
+func (ef *embeddedFileInfo) ModTime() time.Time {
+	return ef.FileModTime
+}
+
+// IsDir returns the abbreviation for Mode().IsDir() (always false)
+// (implementing os.FileInfo)
+func (ef *embeddedFileInfo) IsDir() bool {
+	return false
+}
+
+// Sys returns the underlying data source (always nil)
+// (implementing os.FileInfo)
+func (ef *embeddedFileInfo) Sys() interface{} {
+	return nil
+}

vendor/github.com/GeertJohan/go.rice/embedded/embedded.go

@@ -0,0 +1,80 @@
+// Package embedded defines embedded data types that are shared between the go.rice package and generated code.
+package embedded
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+const (
+	EmbedTypeGo   = 0
+	EmbedTypeSyso = 1
+)
+
+// EmbeddedBox defines an embedded box
+type EmbeddedBox struct {
+	Name      string                   // box name
+	Time      time.Time                // embed time
+	EmbedType int                      // kind of embedding
+	Files     map[string]*EmbeddedFile // ALL embedded files by full path
+	Dirs      map[string]*EmbeddedDir  // ALL embedded dirs by full path
+}
+
+// Link creates the ChildDirs and ChildFiles links in all EmbeddedDir's
+func (e *EmbeddedBox) Link() {
+	for path, ed := range e.Dirs {
+		fmt.Println(path)
+		ed.ChildDirs = make([]*EmbeddedDir, 0)
+		ed.ChildFiles = make([]*EmbeddedFile, 0)
+	}
+	for path, ed := range e.Dirs {
+		parentDirpath, _ := filepath.Split(path)
+		if strings.HasSuffix(parentDirpath, "/") {
+			parentDirpath = parentDirpath[:len(parentDirpath)-1]
+		}
+		parentDir := e.Dirs[parentDirpath]
+		if parentDir == nil {
+			panic("parentDir `" + parentDirpath + "` is missing in embedded box")
+		}
+		parentDir.ChildDirs = append(parentDir.ChildDirs, ed)
+	}
+	for path, ef := range e.Files {
+		dirpath, _ := filepath.Split(path)
+		if strings.HasSuffix(dirpath, "/") {
+			dirpath = dirpath[:len(dirpath)-1]
+		}
+		dir := e.Dirs[dirpath]
+		if dir == nil {
+			panic("dir `" + dirpath + "` is missing in embedded box")
+		}
+		dir.ChildFiles = append(dir.ChildFiles, ef)
+	}
+}
+
+// EmbeddedDir is instanced in the code generated by the rice tool and contains all necicary information about an embedded file
+type EmbeddedDir struct {
+	Filename   string
+	DirModTime time.Time
+	ChildDirs  []*EmbeddedDir  // direct childs, as returned by virtualDir.Readdir()
+	ChildFiles []*EmbeddedFile // direct childs, as returned by virtualDir.Readdir()
+}
+
+// EmbeddedFile is instanced in the code generated by the rice tool and contains all necicary information about an embedded file
+type EmbeddedFile struct {
+	Filename    string // filename
+	FileModTime time.Time
+	Content     string
+}
+
+// EmbeddedBoxes is a public register of embedded boxes
+var EmbeddedBoxes = make(map[string]*EmbeddedBox)
+
+// RegisterEmbeddedBox registers an EmbeddedBox
+func RegisterEmbeddedBox(name string, box *EmbeddedBox) {
+	if _, exists := EmbeddedBoxes[name]; exists {
+		panic(fmt.Sprintf("EmbeddedBox with name `%s` exists already", name))
+	}
+	EmbeddedBoxes[name] = box
+}

vendor/github.com/GeertJohan/go.rice/file.go

@@ -0,0 +1,144 @@
+package rice
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+)
+
+// File implements the io.Reader, io.Seeker, io.Closer and http.File interfaces
+type File struct {
+	// File abstracts file methods so the user doesn't see the difference between rice.virtualFile, rice.virtualDir and os.File
+	// TODO: maybe use internal File interface and four implementations: *os.File, appendedFile, virtualFile, virtualDir
+
+	// real file on disk
+	realF *os.File
+
+	// when embedded (go)
+	virtualF *virtualFile
+	virtualD *virtualDir
+
+	// when appended (zip)
+	appendedF          *appendedFile
+	appendedFileReader *bytes.Reader
+	// TODO: is appendedFileReader subject of races? Might need a lock here..
+}
+
+// Close is like (*os.File).Close()
+// Visit http://golang.org/pkg/os/#File.Close for more information
+func (f *File) Close() error {
+	if f.appendedF != nil {
+		if f.appendedFileReader == nil {
+			return errors.New("already closed")
+		}
+		f.appendedFileReader = nil
+		return nil
+	}
+	if f.virtualF != nil {
+		return f.virtualF.close()
+	}
+	if f.virtualD != nil {
+		return f.virtualD.close()
+	}
+	return f.realF.Close()
+}
+
+// Stat is like (*os.File).Stat()
+// Visit http://golang.org/pkg/os/#File.Stat for more information
+func (f *File) Stat() (os.FileInfo, error) {
+	if f.appendedF != nil {
+		if f.appendedF.dir {
+			return f.appendedF.dirInfo, nil
+		}
+		if f.appendedFileReader == nil {
+			return nil, errors.New("file is closed")
+		}
+		return f.appendedF.zipFile.FileInfo(), nil
+	}
+	if f.virtualF != nil {
+		return f.virtualF.stat()
+	}
+	if f.virtualD != nil {
+		return f.virtualD.stat()
+	}
+	return f.realF.Stat()
+}
+
+// Readdir is like (*os.File).Readdir()
+// Visit http://golang.org/pkg/os/#File.Readdir for more information
+func (f *File) Readdir(count int) ([]os.FileInfo, error) {
+	if f.appendedF != nil {
+		if f.appendedF.dir {
+			fi := make([]os.FileInfo, 0, len(f.appendedF.children))
+			for _, childAppendedFile := range f.appendedF.children {
+				if childAppendedFile.dir {
+					fi = append(fi, childAppendedFile.dirInfo)
+				} else {
+					fi = append(fi, childAppendedFile.zipFile.FileInfo())
+				}
+			}
+			return fi, nil
+		}
+		//++ TODO: is os.ErrInvalid the correct error for Readdir on file?
+		return nil, os.ErrInvalid
+	}
+	if f.virtualF != nil {
+		return f.virtualF.readdir(count)
+	}
+	if f.virtualD != nil {
+		return f.virtualD.readdir(count)
+	}
+	return f.realF.Readdir(count)
+}
+
+// Read is like (*os.File).Read()
+// Visit http://golang.org/pkg/os/#File.Read for more information
+func (f *File) Read(bts []byte) (int, error) {
+	if f.appendedF != nil {
+		if f.appendedFileReader == nil {
+			return 0, &os.PathError{
+				Op:   "read",
+				Path: filepath.Base(f.appendedF.zipFile.Name),
+				Err:  errors.New("file is closed"),
+			}
+		}
+		if f.appendedF.dir {
+			return 0, &os.PathError{
+				Op:   "read",
+				Path: filepath.Base(f.appendedF.zipFile.Name),
+				Err:  errors.New("is a directory"),
+			}
+		}
+		return f.appendedFileReader.Read(bts)
+	}
+	if f.virtualF != nil {
+		return f.virtualF.read(bts)
+	}
+	if f.virtualD != nil {
+		return f.virtualD.read(bts)
+	}
+	return f.realF.Read(bts)
+}
+
+// Seek is like (*os.File).Seek()
+// Visit http://golang.org/pkg/os/#File.Seek for more information
+func (f *File) Seek(offset int64, whence int) (int64, error) {
+	if f.appendedF != nil {
+		if f.appendedFileReader == nil {
+			return 0, &os.PathError{
+				Op:   "seek",
+				Path: filepath.Base(f.appendedF.zipFile.Name),
+				Err:  errors.New("file is closed"),
+			}
+		}
+		return f.appendedFileReader.Seek(offset, whence)
+	}
+	if f.virtualF != nil {
+		return f.virtualF.seek(offset, whence)
+	}
+	if f.virtualD != nil {
+		return f.virtualD.seek(offset, whence)
+	}
+	return f.realF.Seek(offset, whence)
+}

vendor/github.com/GeertJohan/go.rice/http.go

@@ -0,0 +1,21 @@
+package rice
+
+import (
+	"net/http"
+)
+
+// HTTPBox implements http.FileSystem which allows the use of Box with a http.FileServer.
+//   e.g.: http.Handle("/", http.FileServer(rice.MustFindBox("http-files").HTTPBox()))
+type HTTPBox struct {
+	*Box
+}
+
+// HTTPBox creates a new HTTPBox from an existing Box
+func (b *Box) HTTPBox() *HTTPBox {
+	return &HTTPBox{b}
+}
+
+// Open returns a File using the http.File interface
+func (hb *HTTPBox) Open(name string) (http.File, error) {
+	return hb.Box.Open(name)
+}

vendor/github.com/GeertJohan/go.rice/sort.go

@@ -0,0 +1,19 @@
+package rice
+
+import "os"
+
+// SortByName allows an array of os.FileInfo objects
+// to be easily sorted by filename using sort.Sort(SortByName(array))
+type SortByName []os.FileInfo
+
+func (f SortByName) Len() int           { return len(f) }
+func (f SortByName) Less(i, j int) bool { return f[i].Name() < f[j].Name() }
+func (f SortByName) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
+
+// SortByModified allows an array of os.FileInfo objects
+// to be easily sorted by modified date using sort.Sort(SortByModified(array))
+type SortByModified []os.FileInfo
+
+func (f SortByModified) Len() int           { return len(f) }
+func (f SortByModified) Less(i, j int) bool { return f[i].ModTime().Unix() > f[j].ModTime().Unix() }
+func (f SortByModified) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }

vendor/github.com/GeertJohan/go.rice/virtual.go

@@ -0,0 +1,252 @@
+package rice
+
+import (
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+
+	"github.com/GeertJohan/go.rice/embedded"
+)
+
+//++ TODO: IDEA: merge virtualFile and virtualDir, this decreases work done by rice.File
+
+// Error indicating some function is not implemented yet (but available to satisfy an interface)
+var ErrNotImplemented = errors.New("not implemented yet")
+
+// virtualFile is a 'stateful' virtual file.
+// virtualFile wraps an *EmbeddedFile for a call to Box.Open() and virtualizes 'read cursor' (offset) and 'closing'.
+// virtualFile is only internally visible and should be exposed through rice.File
+type virtualFile struct {
+	*embedded.EmbeddedFile       // the actual embedded file, embedded to obtain methods
+	offset                 int64 // read position on the virtual file
+	closed                 bool  // closed when true
+}
+
+// create a new virtualFile for given EmbeddedFile
+func newVirtualFile(ef *embedded.EmbeddedFile) *virtualFile {
+	vf := &virtualFile{
+		EmbeddedFile: ef,
+		offset:       0,
+		closed:       false,
+	}
+	return vf
+}
+
+//++ TODO check for nil pointers in all these methods. When so: return os.PathError with Err: os.ErrInvalid
+
+func (vf *virtualFile) close() error {
+	if vf.closed {
+		return &os.PathError{
+			Op:   "close",
+			Path: vf.EmbeddedFile.Filename,
+			Err:  errors.New("already closed"),
+		}
+	}
+	vf.EmbeddedFile = nil
+	vf.closed = true
+	return nil
+}
+
+func (vf *virtualFile) stat() (os.FileInfo, error) {
+	if vf.closed {
+		return nil, &os.PathError{
+			Op:   "stat",
+			Path: vf.EmbeddedFile.Filename,
+			Err:  errors.New("bad file descriptor"),
+		}
+	}
+	return (*embeddedFileInfo)(vf.EmbeddedFile), nil
+}
+
+func (vf *virtualFile) readdir(count int) ([]os.FileInfo, error) {
+	if vf.closed {
+		return nil, &os.PathError{
+			Op:   "readdir",
+			Path: vf.EmbeddedFile.Filename,
+			Err:  errors.New("bad file descriptor"),
+		}
+	}
+	//TODO: return proper error for a readdir() call on a file
+	return nil, ErrNotImplemented
+}
+
+func (vf *virtualFile) read(bts []byte) (int, error) {
+	if vf.closed {
+		return 0, &os.PathError{
+			Op:   "read",
+			Path: vf.EmbeddedFile.Filename,
+			Err:  errors.New("bad file descriptor"),
+		}
+	}
+
+	end := vf.offset + int64(len(bts))
+
+	if end >= int64(len(vf.Content)) {
+		// end of file, so return what we have + EOF
+		n := copy(bts, vf.Content[vf.offset:])
+		vf.offset = 0
+		return n, io.EOF
+	}
+
+	n := copy(bts, vf.Content[vf.offset:end])
+	vf.offset += int64(n)
+	return n, nil
+
+}
+
+func (vf *virtualFile) seek(offset int64, whence int) (int64, error) {
+	if vf.closed {
+		return 0, &os.PathError{
+			Op:   "seek",
+			Path: vf.EmbeddedFile.Filename,
+			Err:  errors.New("bad file descriptor"),
+		}
+	}
+	var e error
+
+	//++ TODO: check if this is correct implementation for seek
+	switch whence {
+	case os.SEEK_SET:
+		//++ check if new offset isn't out of bounds, set e when it is, then break out of switch
+		vf.offset = offset
+	case os.SEEK_CUR:
+		//++ check if new offset isn't out of bounds, set e when it is, then break out of switch
+		vf.offset += offset
+	case os.SEEK_END:
+		//++ check if new offset isn't out of bounds, set e when it is, then break out of switch
+		vf.offset = int64(len(vf.EmbeddedFile.Content)) - offset
+	}
+
+	if e != nil {
+		return 0, &os.PathError{
+			Op:   "seek",
+			Path: vf.Filename,
+			Err:  e,
+		}
+	}
+
+	return vf.offset, nil
+}
+
+// virtualDir is a 'stateful' virtual directory.
+// virtualDir wraps an *EmbeddedDir for a call to Box.Open() and virtualizes 'closing'.
+// virtualDir is only internally visible and should be exposed through rice.File
+type virtualDir struct {
+	*embedded.EmbeddedDir
+	offset int // readdir position on the directory
+	closed bool
+}
+
+// create a new virtualDir for given EmbeddedDir
+func newVirtualDir(ed *embedded.EmbeddedDir) *virtualDir {
+	vd := &virtualDir{
+		EmbeddedDir: ed,
+		offset:      0,
+		closed:      false,
+	}
+	return vd
+}
+
+func (vd *virtualDir) close() error {
+	//++ TODO: needs sync mutex?
+	if vd.closed {
+		return &os.PathError{
+			Op:   "close",
+			Path: vd.EmbeddedDir.Filename,
+			Err:  errors.New("already closed"),
+		}
+	}
+	vd.closed = true
+	return nil
+}
+
+func (vd *virtualDir) stat() (os.FileInfo, error) {
+	if vd.closed {
+		return nil, &os.PathError{
+			Op:   "stat",
+			Path: vd.EmbeddedDir.Filename,
+			Err:  errors.New("bad file descriptor"),
+		}
+	}
+	return (*embeddedDirInfo)(vd.EmbeddedDir), nil
+}
+
+func (vd *virtualDir) readdir(n int) (fi []os.FileInfo, err error) {
+
+	if vd.closed {
+		return nil, &os.PathError{
+			Op:   "readdir",
+			Path: vd.EmbeddedDir.Filename,
+			Err:  errors.New("bad file descriptor"),
+		}
+	}
+
+	// Build up the array of our contents
+	var files []os.FileInfo
+
+	// Add the child directories
+	for _, child := range vd.ChildDirs {
+		child.Filename = filepath.Base(child.Filename)
+		files = append(files, (*embeddedDirInfo)(child))
+	}
+
+	// Add the child files
+	for _, child := range vd.ChildFiles {
+		child.Filename = filepath.Base(child.Filename)
+		files = append(files, (*embeddedFileInfo)(child))
+	}
+
+	// Sort it by filename (lexical order)
+	sort.Sort(SortByName(files))
+
+	// Return all contents if that's what is requested
+	if n <= 0 {
+		vd.offset = 0
+		return files, nil
+	}
+
+	// If user has requested past the end of our list
+	// return what we can and send an EOF
+	if vd.offset+n >= len(files) {
+		offset := vd.offset
+		vd.offset = 0
+		return files[offset:], io.EOF
+	}
+
+	offset := vd.offset
+	vd.offset += n
+	return files[offset : offset+n], nil
+
+}
+
+func (vd *virtualDir) read(bts []byte) (int, error) {
+	if vd.closed {
+		return 0, &os.PathError{
+			Op:   "read",
+			Path: vd.EmbeddedDir.Filename,
+			Err:  errors.New("bad file descriptor"),
+		}
+	}
+	return 0, &os.PathError{
+		Op:   "read",
+		Path: vd.EmbeddedDir.Filename,
+		Err:  errors.New("is a directory"),
+	}
+}
+
+func (vd *virtualDir) seek(offset int64, whence int) (int64, error) {
+	if vd.closed {
+		return 0, &os.PathError{
+			Op:   "seek",
+			Path: vd.EmbeddedDir.Filename,
+			Err:  errors.New("bad file descriptor"),
+		}
+	}
+	return 0, &os.PathError{
+		Op:   "seek",
+		Path: vd.Filename,
+		Err:  errors.New("is a directory"),
+	}
+}

vendor/github.com/GeertJohan/go.rice/walk.go

@@ -0,0 +1,122 @@
+package rice
+
+import (
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// Walk is like filepath.Walk()
+// Visit http://golang.org/pkg/path/filepath/#Walk for more information
+func (b *Box) Walk(path string, walkFn filepath.WalkFunc) error {
+
+	pathFile, err := b.Open(path)
+	if err != nil {
+		return err
+	}
+	defer pathFile.Close()
+
+	pathInfo, err := pathFile.Stat()
+	if err != nil {
+		return err
+	}
+
+	if b.IsAppended() || b.IsEmbedded() {
+		return b.walk(path, pathInfo, walkFn)
+	}
+
+	// We don't have any embedded or appended box so use live filesystem mode
+	return filepath.Walk(b.absolutePath+string(os.PathSeparator)+path, func(path string, info os.FileInfo, err error) error {
+
+		// Strip out the box name from the returned paths
+		path = strings.TrimPrefix(path, b.absolutePath+string(os.PathSeparator))
+		return walkFn(path, info, err)
+
+	})
+
+}
+
+// walk recursively descends path.
+// See walk() in $GOROOT/src/pkg/path/filepath/path.go
+func (b *Box) walk(path string, info os.FileInfo, walkFn filepath.WalkFunc) error {
+
+	err := walkFn(path, info, nil)
+	if err != nil {
+		if info.IsDir() && err == filepath.SkipDir {
+			return nil
+		}
+		return err
+	}
+
+	if !info.IsDir() {
+		return nil
+	}
+
+	names, err := b.readDirNames(path)
+	if err != nil {
+		return walkFn(path, info, err)
+	}
+
+	for _, name := range names {
+
+		filename := filepath.Join(path, name)
+		fileObject, err := b.Open(filename)
+		if err != nil {
+			return err
+		}
+		defer fileObject.Close()
+
+		fileInfo, err := fileObject.Stat()
+		if err != nil {
+			if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
+				return err
+			}
+		} else {
+			err = b.walk(filename, fileInfo, walkFn)
+			if err != nil {
+				if !fileInfo.IsDir() || err != filepath.SkipDir {
+					return err
+				}
+			}
+		}
+	}
+
+	return nil
+
+}
+
+// readDirNames reads the directory named by path and returns a sorted list of directory entries.
+// See readDirNames() in $GOROOT/pkg/path/filepath/path.go
+func (b *Box) readDirNames(path string) ([]string, error) {
+
+	f, err := b.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	stat, err := f.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	if !stat.IsDir() {
+		return nil, nil
+	}
+
+	infos, err := f.Readdir(0)
+	if err != nil {
+		return nil, err
+	}
+
+	var names []string
+
+	for _, info := range infos {
+		names = append(names, info.Name())
+	}
+
+	sort.Strings(names)
+	return names, nil
+
+}

vendor/github.com/GeertJohan/go.rice/wercker.yml

@@ -0,0 +1,31 @@
+box: wercker/golang
+
+build:
+  steps:
+    - setup-go-workspace
+    
+    - script:
+        name: get dependencies
+        code: |
+          go get -d -t ./...
+
+    - script:
+        name: build
+        code: |
+            go build -x ./...
+
+    - script:
+        name: test
+        code: |
+          go test -cover ./...
+
+    - script:
+        name: vet
+        code: |
+          go vet ./...
+        
+    - script:
+        name: lint
+        code: |
+          go get github.com/golang/lint/golint
+          golint .

vendor/github.com/daaku/go.zipexe/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2012-2015 Carlos Castillo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/daaku/go.zipexe/readme.md

@@ -0,0 +1,5 @@
+go.zipexe
+=========
+
+This module was taken as-is from https://github.com/cookieo9/resources-go.
+Documentation: https://godoc.org/github.com/daaku/go.zipexe

vendor/github.com/daaku/go.zipexe/zipexe.go

@@ -0,0 +1,142 @@
+// Package zipexe attempts to open an executable binary file as a zip file.
+package zipexe
+
+import (
+	"archive/zip"
+	"debug/elf"
+	"debug/macho"
+	"debug/pe"
+	"errors"
+	"io"
+	"os"
+)
+
+// Opens a zip file by path.
+func Open(path string) (*zip.Reader, error) {
+	_, rd, err := OpenCloser(path)
+	return rd, err
+}
+
+// OpenCloser is like Open but returns an additional Closer to avoid leaking open files.
+func OpenCloser(path string) (io.Closer, *zip.Reader, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	finfo, err := file.Stat()
+	if err != nil {
+		return nil, nil, err
+	}
+	zr, err := NewReader(file, finfo.Size())
+	if err != nil {
+		return nil, nil, err
+	}
+	return file, zr, nil
+}
+
+// Open a zip file, specially handling various binaries that may have been
+// augmented with zip data.
+func NewReader(rda io.ReaderAt, size int64) (*zip.Reader, error) {
+	handlers := []func(io.ReaderAt, int64) (*zip.Reader, error){
+		zip.NewReader,
+		zipExeReaderMacho,
+		zipExeReaderElf,
+		zipExeReaderPe,
+	}
+
+	for _, handler := range handlers {
+		zfile, err := handler(rda, size)
+		if err == nil {
+			return zfile, nil
+		}
+	}
+	return nil, errors.New("Couldn't Open As Executable")
+}
+
+// zipExeReaderMacho treats the file as a Mach-O binary
+// (Mac OS X / Darwin executable) and attempts to find a zip archive.
+func zipExeReaderMacho(rda io.ReaderAt, size int64) (*zip.Reader, error) {
+	file, err := macho.NewFile(rda)
+	if err != nil {
+		return nil, err
+	}
+
+	var max int64
+	for _, load := range file.Loads {
+		seg, ok := load.(*macho.Segment)
+		if ok {
+			// Check if the segment contains a zip file
+			if zfile, err := zip.NewReader(seg, int64(seg.Filesz)); err == nil {
+				return zfile, nil
+			}
+
+			// Otherwise move end of file pointer
+			end := int64(seg.Offset + seg.Filesz)
+			if end > max {
+				max = end
+			}
+		}
+	}
+
+	// No zip file within binary, try appended to end
+	section := io.NewSectionReader(rda, max, size-max)
+	return zip.NewReader(section, section.Size())
+}
+
+// zipExeReaderPe treats the file as a Portable Exectuable binary
+// (Windows executable) and attempts to find a zip archive.
+func zipExeReaderPe(rda io.ReaderAt, size int64) (*zip.Reader, error) {
+	file, err := pe.NewFile(rda)
+	if err != nil {
+		return nil, err
+	}
+
+	var max int64
+	for _, sec := range file.Sections {
+		// Check if this section has a zip file
+		if zfile, err := zip.NewReader(sec, int64(sec.Size)); err == nil {
+			return zfile, nil
+		}
+
+		// Otherwise move end of file pointer
+		end := int64(sec.Offset + sec.Size)
+		if end > max {
+			max = end
+		}
+	}
+
+	// No zip file within binary, try appended to end
+	section := io.NewSectionReader(rda, max, size-max)
+	return zip.NewReader(section, section.Size())
+}
+
+// zipExeReaderElf treats the file as a ELF binary
+// (linux/BSD/etc... executable) and attempts to find a zip archive.
+func zipExeReaderElf(rda io.ReaderAt, size int64) (*zip.Reader, error) {
+	file, err := elf.NewFile(rda)
+	if err != nil {
+		return nil, err
+	}
+
+	var max int64
+	for _, sect := range file.Sections {
+		if sect.Type == elf.SHT_NOBITS {
+			continue
+		}
+
+		// Check if this section has a zip file
+		if zfile, err := zip.NewReader(sect, int64(sect.Size)); err == nil {
+			return zfile, nil
+		}
+
+		// Otherwise move end of file pointer
+		end := int64(sect.Offset + sect.Size)
+		if end > max {
+			max = end
+		}
+	}
+
+	// No zip file within binary, try appended to end
+	section := io.NewSectionReader(rda, max, size-max)
+	return zip.NewReader(section, section.Size())
+}

vendor/github.com/hlandau/passlib/COPYING

@@ -0,0 +1,39 @@
+passlib is a Golang password verification library strongly inspired by and
+derived from Python passlib (<https://pypi.python.org/pypi/passlib>). The BSD
+license is preserved and extended to all new code.
+
+License for Passlib
+===================
+Passlib is (c) `Assurance Technologies <http://www.assurancetechnologies.com>`_,
+and is released under the `BSD license <http://www.opensource.org/licenses/bsd-license.php>`_::
+
+    Passlib
+    Copyright (c) 2008-2012 Assurance Technologies, LLC.
+    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 Assurance Technologies, nor the names of the
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/hlandau/passlib/README.md

@@ -0,0 +1,95 @@
+passlib for go
+==============
+
+[![GoDoc](https://godoc.org/gopkg.in/hlandau/passlib.v1?status.svg)](https://godoc.org/gopkg.in/hlandau/passlib.v1) [![Build Status](https://travis-ci.org/hlandau/passlib.svg?branch=master)](https://travis-ci.org/hlandau/passlib)
+
+[Python's passlib](https://pythonhosted.org/passlib/) is quite an amazing
+library. I'm not sure there's a password library in existence with more thought
+put into it, or with more support for obscure password formats.
+
+This is a skeleton of a port of passlib to Go. It dogmatically adopts the
+modular crypt format, which [passlib has excellent documentation for](https://pythonhosted.org/passlib/modular_crypt_format.html#modular-crypt-format).
+
+Currently, it supports sha256-crypt, sha512-crypt, scrypt-sha256, bcrypt and
+passlib's bcrypt-sha256 variant. By default, it will hash using scrypt-sha256
+and verify existing hashes using any of these schemes.
+
+Example Usage
+-------------
+There's a default context for ease of use. Most people need only concern
+themselves with the functions `Hash` and `Verify`:
+
+```go
+// Hash a plaintext, UTF-8 password.
+func Hash(password string) (hash string, err error)
+
+// Verifies a plaintext, UTF-8 password using a previously derived hash.
+// Returns non-nil err if verification fails.
+//
+// Also returns an upgraded password hash if the hash provided is
+// deprecated.
+func Verify(password, hash string) (newHash string, err error)
+```
+
+Here's a rough skeleton of typical usage.
+
+```go
+import "gopkg.in/hlandau/passlib.v1"
+
+func RegisterUser() {
+  (...)
+
+  password := get a (UTF-8, plaintext) password from somewhere
+
+  hash, err := passlib.Hash(password)
+  if err != nil {
+    // couldn't hash password for some reason
+    return
+  }
+
+  (store hash in database, etc.)
+}
+
+func CheckPassword() bool {
+  password := get the password the user entered
+  hash := the hash you stored from the call to Hash()
+
+  newHash, err := passlib.Verify(password, hash)
+  if err != nil {
+    // incorrect password, malformed hash, etc.
+    // either way, reject
+    return false
+  }
+
+  // The context has decided, as per its policy, that
+  // the hash which was used to validate the password
+  // should be changed. It has upgraded the hash using
+  // the verified password.
+  if newHash != "" {
+    (store newHash in database, replacing old hash)
+  }
+
+  return true
+}
+```
+
+scrypt Modular Crypt Format
+---------------------------
+Since scrypt does not have a pre-existing modular crypt format standard, I made one. It's as follows:
+
+    $s2$N$r$p$salt$hash
+
+...where `N`, `r` and `p` are the respective difficulty parameters to scrypt as positive decimal integers without leading zeroes, and `salt` and `hash` are base64-encoded binary strings. Note that the RFC 4648 base64 encoding is used (not the one used by sha256-crypt and sha512-crypt).
+
+TODO
+----
+
+  - PBKDF2
+
+Licence
+-------
+passlib is partially derived from Python's passlib and so maintains its BSD license.
+
+    © 2008-2012 Assurance Technologies LLC.  (Python passlib)  BSD License
+    © 2014 Hugo Landau <hlandau@devever.net>  BSD License
+

vendor/github.com/hlandau/passlib/passlib.go

@@ -0,0 +1,177 @@
+// Package passlib provides a simple password hashing and verification
+// interface abstracting multiple password hashing schemes.
+//
+// Most people need concern themselves only with the functions Hash
+// and Verify, which uses the default context and sensible defaults.
+package passlib // import "gopkg.in/hlandau/passlib.v1"
+
+import "gopkg.in/hlandau/passlib.v1/abstract"
+import "gopkg.in/hlandau/passlib.v1/hash/scrypt"
+import "gopkg.in/hlandau/passlib.v1/hash/sha2crypt"
+import "gopkg.in/hlandau/passlib.v1/hash/bcryptsha256"
+import "gopkg.in/hlandau/passlib.v1/hash/bcrypt"
+import "gopkg.in/hlandau/easymetric.v1/cexp"
+
+var cHashCalls = cexp.NewCounter("passlib.ctx.hashCalls")
+var cVerifyCalls = cexp.NewCounter("passlib.ctx.verifyCalls")
+var cSuccessfulVerifyCalls = cexp.NewCounter("passlib.ctx.successfulVerifyCalls")
+var cFailedVerifyCalls = cexp.NewCounter("passlib.ctx.failedVerifyCalls")
+var cSuccessfulVerifyCallsWithUpgrade = cexp.NewCounter("passlib.ctx.successfulVerifyCallsWithUpgrade")
+var cSuccessfulVerifyCallsDeferringUpgrade = cexp.NewCounter("passlib.ctx.successfulVerifyCallsDeferringUpgrade")
+
+// The default schemes, most preferred first. The first scheme will be used to
+// hash passwords, and any of the schemes may be used to verify existing
+// passwords. The contents of this value may change with subsequent releases.
+var DefaultSchemes = []abstract.Scheme{
+	scrypt.SHA256Crypter,
+	sha2crypt.Crypter256,
+	sha2crypt.Crypter512,
+	bcryptsha256.Crypter,
+	bcrypt.Crypter,
+}
+
+// A password hashing context, that uses a given set of schemes to hash and
+// verify passwords.
+type Context struct {
+	// Slice of schemes to use, most preferred first.
+	//
+	// If left uninitialized, a sensible default set of schemes will be used.
+	//
+	// An upgrade hash (see the newHash return value of the Verify method of the
+	// abstract.Scheme interface) will be issued whenever a password is validated
+	// using a scheme which is not the first scheme in this slice.
+	Schemes []abstract.Scheme
+}
+
+func (ctx *Context) schemes() []abstract.Scheme {
+	if ctx.Schemes == nil {
+		return DefaultSchemes
+	}
+
+	return ctx.Schemes
+}
+
+// Hashes a UTF-8 plaintext password using the context and produces a password hash.
+//
+// If stub is "", one is generated automaticaly for the preferred password hashing
+// scheme; you should specify stub as "" in almost all cases.
+//
+// The provided or randomly generated stub is used to deterministically hash
+// the password. The returned hash is in modular crypt format.
+//
+// If the context has not been specifically configured, a sensible default policy
+// is used. See the fields of Context.
+func (ctx *Context) Hash(password string) (hash string, err error) {
+	cHashCalls.Add(1)
+
+	return ctx.schemes()[0].Hash(password)
+}
+
+// Verifies a UTF-8 plaintext password using a previously derived password hash
+// and the default context. Returns nil err only if the password is valid.
+//
+// If the hash is determined to be deprecated based on the context policy, and
+// the password is valid, the password is hashed using the preferred password
+// hashing scheme and returned in newHash. You should use this to upgrade any
+// stored password hash in your database.
+//
+// newHash is empty if the password was not valid or if no upgrade is required.
+//
+// You should treat any non-nil err as a password verification error.
+func (ctx *Context) Verify(password, hash string) (newHash string, err error) {
+	return ctx.verify(password, hash, true)
+}
+
+// Like Verify, but does not hash an upgrade password when upgrade is required.
+func (ctx *Context) VerifyNoUpgrade(password, hash string) error {
+	_, err := ctx.verify(password, hash, false)
+	return err
+}
+
+func (ctx *Context) verify(password, hash string, canUpgrade bool) (newHash string, err error) {
+	cVerifyCalls.Add(1)
+
+	for i, scheme := range ctx.schemes() {
+		if !scheme.SupportsStub(hash) {
+			continue
+		}
+
+		err = scheme.Verify(password, hash)
+		if err != nil {
+			cFailedVerifyCalls.Add(1)
+			return "", err
+		}
+
+		cSuccessfulVerifyCalls.Add(1)
+		if i != 0 || scheme.NeedsUpdate(hash) {
+			if canUpgrade {
+				cSuccessfulVerifyCallsWithUpgrade.Add(1)
+
+				// If the scheme is not the first scheme, try and rehash with the
+				// preferred scheme.
+				if newHash, err2 := ctx.Hash(password); err2 == nil {
+					return newHash, nil
+				}
+			} else {
+				cSuccessfulVerifyCallsDeferringUpgrade.Add(1)
+			}
+		}
+
+		return "", nil
+	}
+
+	return "", abstract.ErrUnsupportedScheme
+}
+
+// Determines whether a stub or hash needs updating according to the policy of
+// the context.
+func (ctx *Context) NeedsUpdate(stub string) bool {
+	for i, scheme := range ctx.schemes() {
+		if scheme.SupportsStub(stub) {
+			return i != 0 || scheme.NeedsUpdate(stub)
+		}
+	}
+
+	return false
+}
+
+// The default context, which uses sensible defaults. Most users should not
+// reconfigure this. The defaults may change over time, so you may wish
+// to reconfigure the context or use a custom context if you want precise
+// control over the hashes used.
+var DefaultContext Context
+
+// Hashes a UTF-8 plaintext password using the default context and produces a
+// password hash. Chooses the preferred password hashing scheme based on the
+// configured policy. The default policy is sensible.
+func Hash(password string) (hash string, err error) {
+	return DefaultContext.Hash(password)
+}
+
+// Verifies a UTF-8 plaintext password using a previously derived password hash
+// and the default context. Returns nil err only if the password is valid.
+//
+// If the hash is determined to be deprecated based on policy, and the password
+// is valid, the password is hashed using the preferred password hashing scheme
+// and returned in newHash. You should use this to upgrade any stored password
+// hash in your database.
+//
+// newHash is empty if the password was invalid or no upgrade is required.
+//
+// You should treat any non-nil err as a password verification error.
+func Verify(password, hash string) (newHash string, err error) {
+	return DefaultContext.Verify(password, hash)
+}
+
+// Like Verify, but never upgrades.
+func VerifyNoUpgrade(password, hash string) error {
+	return DefaultContext.VerifyNoUpgrade(password, hash)
+}
+
+// Uses the default context to determine whether a stub or hash needs updating.
+func NeedsUpdate(stub string) bool {
+	return DefaultContext.NeedsUpdate(stub)
+}
+
+// © 2008-2012 Assurance Technologies LLC.  (Python passlib)  BSD License
+// © 2014 Hugo Landau <hlandau@devever.net>  BSD License

vendor/github.com/icza/session/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/icza/session/README.md

@@ -0,0 +1,114 @@
+# Session
+
+[![Build Status](https://travis-ci.org/icza/session.svg?branch=master)](https://travis-ci.org/icza/session)
+[![GoDoc](https://godoc.org/github.com/icza/session?status.svg)](https://godoc.org/github.com/icza/session)
+[![Go Report Card](https://goreportcard.com/badge/github.com/icza/session)](https://goreportcard.com/report/github.com/icza/session)
+[![codecov](https://codecov.io/gh/icza/session/branch/master/graph/badge.svg)](https://codecov.io/gh/icza/session)
+
+The [Go](https://golang.org/) standard library includes a nice [http server](https://golang.org/pkg/net/http/), but unfortunately it lacks a very basic and important feature: _HTTP session management_.
+
+This package provides an easy-to-use, extensible and secure session implementation and management. Package documentation can be found and godoc.org:
+
+https://godoc.org/github.com/icza/session
+
+This is "just" an HTTP session implementation and management, you can use it as-is, or with any existing Go web toolkits and frameworks.
+
+## Overview
+
+There are 3 key _players_ in the package:
+
+- **`Session`** is the (HTTP) session interface. We can use it to store and retrieve constant and variable attributes from it.
+- **`Store`** is a session store interface which is responsible to store sessions and make them retrievable by their IDs at the server side.
+- **`Manager`** is a session manager interface which is responsible to acquire a `Session` from an (incoming) HTTP request, and to add a `Session` to an HTTP response to let the client know about the session. A `Manager` has a backing `Store` which is responsible to manage `Session` values at server side.
+
+_Players_ of this package are represented by interfaces, and various implementations are provided for all these players.
+You are not bound by the provided implementations, feel free to provide your own implementations for any of the players.
+
+## Usage
+
+Usage can't be simpler than this. To get the current session associated with the [http.Request](https://golang.org/pkg/net/http/#Request):
+
+    sess := session.Get(r)
+    if sess == nil {
+        // No session (yet)
+    } else {
+        // We have a session, use it
+    }
+
+To create a new session (e.g. on a successful login) and add it to an [http.ResponseWriter](https://golang.org/pkg/net/http/#ResponseWriter) (to let the client know about the session):
+
+    sess := session.NewSession()
+    session.Add(sess, w)
+
+Let's see a more advanced session creation: let's provide a constant attribute (for the lifetime of the session) and an initial, variable attribute:
+
+    sess := session.NewSessionOptions(&session.SessOptions{
+        CAttrs: map[string]interface{}{"UserName": userName},
+        Attrs:  map[string]interface{}{"Count": 1},
+    })
+
+And to access these attributes and change value of `"Count"`:
+
+    userName := sess.CAttr("UserName")
+    count := sess.Attr("Count").(int) // Type assertion, you might wanna check if it succeeds
+    sess.SetAttr("Count", count+1)    // Increment count
+
+(Of course variable attributes can be added later on too with `Session.SetAttr()`, not just at session creation.)
+
+To remove a session (e.g. on logout):
+
+    session.Remove(sess, w)
+
+Check out the [session demo application](https://github.com/icza/session/blob/master/session_demo/session_demo.go) which shows all these in action.
+
+## Google App Engine support
+
+The package provides support for Google App Engine (GAE) platform.
+
+The documentation doesn't include it (due to the `+build appengine` build constraint), but here it is: [gae_memcache_store.go](https://github.com/icza/session/blob/master/gae_memcache_store.go)
+
+The implementation stores sessions in the Memcache and also saves sessions in the Datastore as a backup
+in case data would be removed from the Memcache. This behaviour is optional, Datastore can be disabled completely.
+You can also choose whether saving to Datastore happens synchronously (in the same goroutine)
+or asynchronously (in another goroutine), resulting in faster response times.
+
+We can use `NewMemcacheStore()` and `NewMemcacheStoreOptions()` functions to create a session Store implementation
+which stores sessions in GAE's Memcache. Important to note that since accessing the Memcache relies on
+Appengine Context which is bound to an `http.Request`, the returned Store can only be used for the lifetime of a request!
+Note that the Store will automatically "flush" sessions accessed from it when the Store is closed,
+so it is very important to close the Store at the end of your request; this is usually done by closing
+the session manager to which you passed the store (preferably with the defer statement).
+
+So in each request handling we have to create a new session manager using a new Store, and we can use the session manager
+to do session-related tasks, something like this:
+
+    ctx := appengine.NewContext(r)
+    sessmgr := session.NewCookieManager(session.NewMemcacheStore(ctx))
+    defer sessmgr.Close() // This will ensure changes made to the session are auto-saved
+                          // in Memcache (and optionally in the Datastore).
+
+    sess := sessmgr.Get(r) // Get current session
+    if sess != nil {
+        // Session exists, do something with it.
+        ctx.Infof("Count: %v", sess.Attr("Count"))
+    } else {
+        // No session yet, let's create one and add it:
+        sess = session.NewSession()
+        sess.SetAttr("Count", 1)
+        sessmgr.Add(sess, w)
+    }
+
+Expired sessions are not automatically removed from the Datastore. To remove expired sessions, the package
+provides a `PurgeExpiredSessFromDSFunc()` function which returns an [http.HandlerFunc](https://golang.org/pkg/net/http/#HandlerFunc).
+It is recommended to register the returned handler function to a path which then can be defined
+as a cron job to be called periodically, e.g. in every 30 minutes or so (your choice).
+As cron handlers may run up to 10 minutes, the returned handler will stop at 8 minutes
+to complete safely even if there are more expired, undeleted sessions.
+It can be registered like this:
+
+    http.HandleFunc("/demo/purge", session.PurgeExpiredSessFromDSFunc(""))
+
+Check out the GAE session demo application which shows how it can be used.
+[cron.yaml](https://github.com/icza/session/blob/master/gae_session_demo/cron.yaml) file of the demo shows how a cron job can be defined to purge expired sessions.
+
+Check out the [GAE session demo application](https://github.com/icza/session/blob/master/gae_session_demo/gae_session_demo.go) which shows how to use this in action.

vendor/github.com/icza/session/cookie_manager.go

@@ -0,0 +1,123 @@
+/*
+
+A secure, cookie based session Manager implementation.
+
+*/
+
+package session
+
+import (
+	"net/http"
+	"time"
+)
+
+// CookieManager is a secure, cookie based session Manager implementation.
+// Only the session ID is transmitted / stored at the clients, and it is managed using cookies.
+type CookieManager struct {
+	store Store // Backing Store
+
+	sessIDCookieName string // Name of the cookie used for storing the session id
+	cookieSecure     bool   // Tells if session ID cookies are to be sent only over HTTPS
+	cookieMaxAgeSec  int    // Max age for session ID cookies in seconds
+	cookiePath       string // Cookie path to use
+}
+
+// CookieMngrOptions defines options that may be passed when creating a new CookieManager.
+// All fields are optional; default value will be used for any field that has the zero value.
+type CookieMngrOptions struct {
+	// Name of the cookie used for storing the session id; default value is "sessid"
+	SessIDCookieName string
+
+	// Tells if session ID cookies are allowed to be sent over unsecure HTTP too (else only HTTPS);
+	// default value is false (only HTTPS)
+	AllowHTTP bool
+
+	// Max age for session ID cookies; default value is 30 days
+	CookieMaxAge time.Duration
+
+	// Cookie path to use; default value is the root: "/"
+	CookiePath string
+}
+
+// Pointer to zero value of CookieMngrOptions to be reused for efficiency.
+var zeroCookieMngrOptions = new(CookieMngrOptions)
+
+// NewCookieManager creates a new, cookie based session Manager with default options.
+// Default values of options are listed in the CookieMngrOptions type.
+func NewCookieManager(store Store) Manager {
+	return NewCookieManagerOptions(store, zeroCookieMngrOptions)
+}
+
+// NewCookieManagerOptions creates a new, cookie based session Manager with the specified options.
+func NewCookieManagerOptions(store Store, o *CookieMngrOptions) Manager {
+	m := &CookieManager{
+		store:            store,
+		cookieSecure:     !o.AllowHTTP,
+		sessIDCookieName: o.SessIDCookieName,
+		cookiePath:       o.CookiePath,
+	}
+
+	if m.sessIDCookieName == "" {
+		m.sessIDCookieName = "sessid"
+	}
+	if o.CookieMaxAge == 0 {
+		m.cookieMaxAgeSec = 30 * 24 * 60 * 60 // 30 days max age
+	} else {
+		m.cookieMaxAgeSec = int(o.CookieMaxAge.Seconds())
+	}
+	if m.cookiePath == "" {
+		m.cookiePath = "/"
+	}
+
+	return m
+}
+
+// Get is to implement Manager.Get().
+func (m *CookieManager) Get(r *http.Request) Session {
+	c, err := r.Cookie(m.sessIDCookieName)
+	if err != nil {
+		return nil
+	}
+
+	return m.store.Get(c.Value)
+}
+
+// Add is to implement Manager.Add().
+func (m *CookieManager) Add(sess Session, w http.ResponseWriter) {
+	// HttpOnly: do not allow non-HTTP access to it (like javascript) to prevent stealing it...
+	// Secure: only send it over HTTPS
+	// MaxAge: to specify the max age of the cookie in seconds, else it's a session cookie and gets deleted after the browser is closed.
+
+	c := http.Cookie{
+		Name:     m.sessIDCookieName,
+		Value:    sess.ID(),
+		Path:     m.cookiePath,
+		HttpOnly: true,
+		Secure:   m.cookieSecure,
+		MaxAge:   m.cookieMaxAgeSec,
+	}
+	http.SetCookie(w, &c)
+
+	m.store.Add(sess)
+}
+
+// Remove is to implement Manager.Remove().
+func (m *CookieManager) Remove(sess Session, w http.ResponseWriter) {
+	// Set the cookie with empty value and 0 max age
+	c := http.Cookie{
+		Name:     m.sessIDCookieName,
+		Value:    "",
+		Path:     m.cookiePath,
+		HttpOnly: true,
+		Secure:   m.cookieSecure,
+		MaxAge:   -1, // MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
+	}
+	http.SetCookie(w, &c)
+
+	m.store.Remove(sess)
+}
+
+// Close is to implement Manager.Close().
+func (m *CookieManager) Close() {
+	m.store.Close()
+}

vendor/github.com/icza/session/doc.go

@@ -0,0 +1,117 @@
+/*
+
+Package session provides an easy-to-use, extensible and secure HTTP session implementation and management.
+
+This is "just" an HTTP session implementation and management, you can use it as-is, or with any existing Go web toolkits and frameworks.
+Package documentation can be found and godoc.org:
+
+https://godoc.org/github.com/icza/session
+
+Overview
+
+There are 3 key players in the package:
+
+- Session is the (HTTP) session interface. We can use it to store and retrieve constant and variable attributes from it.
+
+- Store is a session store interface which is responsible to store sessions and make them retrievable by their IDs at the server side.
+
+- Manager is a session manager interface which is responsible to acquire a Session from an (incoming) HTTP request, and to add a Session to an HTTP response to let the client know about the session. A Manager has a backing Store which is responsible to manage Session values at server side.
+
+Players of this package are represented by interfaces, and various implementations are provided for all these players.
+You are not bound by the provided implementations, feel free to provide your own implementations for any of the players.
+
+Usage
+
+Usage can't be simpler than this. To get the current session associated with the http.Request:
+
+    sess := session.Get(r)
+    if sess == nil {
+        // No session (yet)
+    } else {
+        // We have a session, use it
+    }
+
+To create a new session (e.g. on a successful login) and add it to an http.ResponseWriter (to let the client know about the session):
+
+    sess := session.NewSession()
+    session.Add(sess, w)
+
+Let's see a more advanced session creation: let's provide a constant attribute (for the lifetime of the session) and an initial, variable attribute:
+
+    sess := session.NewSessionOptions(&session.SessOptions{
+        CAttrs: map[string]interface{}{"UserName": userName},
+        Attrs:  map[string]interface{}{"Count": 1},
+    })
+
+And to access these attributes and change value of "Count":
+
+    userName := sess.CAttr("UserName")
+    count := sess.Attr("Count").(int) // Type assertion, you might wanna check if it succeeds
+    sess.SetAttr("Count", count+1)    // Increment count
+
+(Of course variable attributes can be added later on too with Session.SetAttr(), not just at session creation.)
+
+To remove a session (e.g. on logout):
+
+    session.Remove(sess, w)
+
+Check out the session demo application which shows all these in action:
+
+https://github.com/icza/session/blob/master/session_demo/session_demo.go
+
+Google App Engine support
+
+The package provides support for Google App Engine (GAE) platform.
+
+The documentation doesn't include it (due to the '+build appengine' build constraint), but here it is:
+
+https://github.com/icza/session/blob/master/gae_memcache_store.go
+
+The implementation stores sessions in the Memcache and also saves sessions in the Datastore as a backup
+in case data would be removed from the Memcache. This behaviour is optional, Datastore can be disabled completely.
+You can also choose whether saving to Datastore happens synchronously (in the same goroutine)
+or asynchronously (in another goroutine), resulting in faster response times.
+
+We can use NewMemcacheStore() and NewMemcacheStoreOptions() functions to create a session Store implementation
+which stores sessions in GAE's Memcache. Important to note that since accessing the Memcache relies on
+Appengine Context which is bound to an http.Request, the returned Store can only be used for the lifetime of a request!
+Note that the Store will automatically "flush" sessions accessed from it when the Store is closed,
+so it is very important to close the Store at the end of your request; this is usually done by closing
+the session manager to which you passed the store (preferably with the defer statement).
+
+So in each request handling we have to create a new session manager using a new Store, and we can use the session manager
+to do session-related tasks, something like this:
+
+    ctx := appengine.NewContext(r)
+    sessmgr := session.NewCookieManager(session.NewMemcacheStore(ctx))
+    defer sessmgr.Close() // This will ensure changes made to the session are auto-saved
+                          // in Memcache (and optionally in the Datastore).
+
+    sess := sessmgr.Get(r) // Get current session
+    if sess != nil {
+        // Session exists, do something with it.
+        ctx.Infof("Count: %v", sess.Attr("Count"))
+    } else {
+        // No session yet, let's create one and add it:
+        sess = session.NewSession()
+        sess.SetAttr("Count", 1)
+        sessmgr.Add(sess, w)
+    }
+
+Expired sessions are not automatically removed from the Datastore. To remove expired sessions, the package
+provides a PurgeExpiredSessFromDSFunc() function which returns an http.HandlerFunc.
+It is recommended to register the returned handler function to a path which then can be defined
+as a cron job to be called periodically, e.g. in every 30 minutes or so (your choice).
+As cron handlers may run up to 10 minutes, the returned handler will stop at 8 minutes
+to complete safely even if there are more expired, undeleted sessions.
+It can be registered like this:
+
+    http.HandleFunc("/demo/purge", session.PurgeExpiredSessFromDSFunc(""))
+
+Check out the GAE session demo application which shows how it can be used.
+cron.yaml file of the demo shows how a cron job can be defined to purge expired sessions.
+
+https://github.com/icza/session/blob/master/gae_session_demo/gae_session_demo.go
+
+*/
+package session

vendor/github.com/icza/session/gae_memcache_store.go

@@ -0,0 +1,375 @@
+// +build appengine
+
+/*
+
+A Google App Engine Memcache session store implementation.
+
+The implementation stores sessions in the Memcache and also saves sessions to the Datastore as a backup
+in case data would be removed from the Memcache. This behaviour is optional, Datastore can be disabled completely.
+You can also choose whether saving to Datastore happens synchronously (in the same goroutine)
+or asynchronously (in another goroutine).
+
+Limitations based on GAE Memcache:
+
+- Since session ids are used in the Memcache keys, session ids can't be longer than 250 chars (bytes, but with Base64 charset it's the same).
+If you also specify a key prefix (in MemcacheStoreOptions), that also counts into it.
+
+- The size of a Session cannot be larger than 1 MB (marshalled into a byte slice).
+
+Note that the Store will automatically "flush" sessions accessed from it when the Store is closed,
+so it is very important to close the Store at the end of your request; this is usually done by closing
+the session manager to which you passed the store (preferably with the defer statement).
+
+Check out the GAE session demo application which shows how to use it properly:
+
+https://github.com/icza/session/blob/master/gae_session_demo/session_demo.go
+
+*/
+
+package session
+
+import (
+	"net/http"
+	"sync"
+	"time"
+
+	"appengine"
+	"appengine/datastore"
+	"appengine/memcache"
+)
+
+// A Google App Engine Memcache session store implementation.
+type memcacheStore struct {
+	ctx appengine.Context // Appengine context used when accessing the Memcache
+
+	keyPrefix string // Prefix to use in front of session ids to construct Memcache key
+	retries   int    // Number of retries to perform in case of general Memcache failures
+
+	codec memcache.Codec // Codec used to marshal and unmarshal a Session to a byte slice
+
+	onlyMemcache       bool   // Tells if sessions are not to be saved in Datastore
+	asyncDatastoreSave bool   // Tells if saving in Datastore should happen asynchronously, in a new goroutine
+	dsEntityName       string // Name of the datastore entity to use to save sessions
+
+	// Map of sessions (mapped from ID) that were accessed using this store; usually it will only be 1.
+	// It is also used as a cache, should the user call Get() with the same id multiple times.
+	sessions map[string]Session
+
+	mux *sync.RWMutex // mutex to synchronize access to sessions
+}
+
+// MemcacheStoreOptions defines options that may be passed when creating a new Memcache session store.
+// All fields are optional; default value will be used for any field that has the zero value.
+type MemcacheStoreOptions struct {
+	// Prefix to use when storing sessions in the Memcache, cannot contain a null byte
+	// and cannot be longer than 250 chars (bytes) when concatenated with the session id; default value is the empty string
+	// The Memcache key will be this prefix and the session id concatenated.
+	KeyPrefix string
+
+	// Number of retries to perform if Memcache operations fail due to general service error;
+	// default value is 3
+	Retries int
+
+	// Codec used to marshal and unmarshal a Session to a byte slice;
+	// Default value is &memcache.Gob (which uses the gob package).
+	Codec *memcache.Codec
+
+	// Tells if sessions are only to be stored in Memcache, and do not store them in Datastore as backup;
+	// as Memcache has no guarantees, it may lose content from time to time, but if Datastore is
+	// also used, the session will automatically be retrieved from the Datastore if not found in Memcache;
+	// default value is false (which means to also save sessions in the Datastore)
+	OnlyMemcache bool
+
+	// Tells if saving in Datastore should happen asynchronously (in a new goroutine, possibly after returning),
+	// if false, session saving in Datastore will happen in the same goroutine, before returning from the request.
+	// Asynchronous saving gives smaller latency (and is enough most of the time as Memcache is always checked first);
+	// default value is false which means to save sessions in the Datastore in the same goroutine, synchronously
+	// Not used if OnlyMemcache=true.
+	// FIXME: See https://github.com/icza/session/issues/3
+	AsyncDatastoreSave bool
+
+	// Name of the entity to use for saving sessions;
+	// default value is "sess_"
+	// Not used if OnlyMemcache=true.
+	DSEntityName string
+}
+
+// SessEntity models the session entity saved to Datastore.
+// The Key is the session id.
+type SessEntity struct {
+	Expires time.Time `datastore:"exp"`
+	Value   []byte    `datastore:"val"`
+}
+
+// Pointer to zero value of MemcacheStoreOptions to be reused for efficiency.
+var zeroMemcacheStoreOptions = new(MemcacheStoreOptions)
+
+// NewMemcacheStore returns a new, GAE Memcache session Store with default options.
+// Default values of options are listed in the MemcacheStoreOptions type.
+//
+// Important! Since accessing the Memcache relies on Appengine Context
+// which is bound to an http.Request, the returned Store can only be used for the lifetime of a request!
+func NewMemcacheStore(ctx appengine.Context) Store {
+	return NewMemcacheStoreOptions(ctx, zeroMemcacheStoreOptions)
+}
+
+const defaultDSEntityName = "sess_" // Default value of DSEntityName.
+
+// NewMemcacheStoreOptions returns a new, GAE Memcache session Store with the specified options.
+//
+// Important! Since accessing the Memcache relies on Appengine Context
+// which is bound to an http.Request, the returned Store can only be used for the lifetime of a request!
+func NewMemcacheStoreOptions(ctx appengine.Context, o *MemcacheStoreOptions) Store {
+	s := &memcacheStore{
+		ctx:                ctx,
+		keyPrefix:          o.KeyPrefix,
+		retries:            o.Retries,
+		onlyMemcache:       o.OnlyMemcache,
+		asyncDatastoreSave: o.AsyncDatastoreSave,
+		dsEntityName:       o.DSEntityName,
+		sessions:           make(map[string]Session, 2),
+		mux:                &sync.RWMutex{},
+	}
+	if s.retries <= 0 {
+		s.retries = 3
+	}
+	if o.Codec != nil {
+		s.codec = *o.Codec
+	} else {
+		s.codec = memcache.Gob
+	}
+	if s.dsEntityName == "" {
+		s.dsEntityName = defaultDSEntityName
+	}
+	return s
+}
+
+// Get is to implement Store.Get().
+// Important! Since sessions are marshalled and stored in the Memcache,
+// the mutex of the Session (Session.RWMutex()) will be different for each
+// Session value (even though they might have the same session id)!
+func (s *memcacheStore) Get(id string) Session {
+	s.mux.RLock()
+	defer s.mux.RUnlock()
+
+	// First check our "cache"
+	if sess := s.sessions[id]; sess != nil {
+		return sess
+	}
+
+	// Next check in Memcache
+	var err error
+	var sess *sessionImpl
+
+	for i := 0; i < s.retries; i++ {
+		var sess_ sessionImpl
+		_, err = s.codec.Get(s.ctx, s.keyPrefix+id, &sess_)
+		if err == memcache.ErrCacheMiss {
+			break // It's not in the Memcache (e.g. invalid sess id or was removed from Memcache by AppEngine)
+		}
+		if err == nil {
+			sess = &sess_
+			break
+		}
+		// Service error? Retry..
+	}
+
+	if sess == nil {
+		if err != nil && err != memcache.ErrCacheMiss {
+			s.ctx.Errorf("Failed to get session from memcache, id: %s, error: %v", id, err)
+		}
+
+		// Ok, we didn't get it from Memcace (either was not there or Memcache service is unavailable).
+		// Now it's time to check in the Datastore.
+		key := datastore.NewKey(s.ctx, s.dsEntityName, id, 0, nil)
+		for i := 0; i < s.retries; i++ {
+			e := SessEntity{}
+			err = datastore.Get(s.ctx, key, &e)
+			if err == datastore.ErrNoSuchEntity {
+				return nil // It's not in the Datastore either
+			}
+			if err != nil {
+				// Service error? Retry..
+				continue
+			}
+			if e.Expires.Before(time.Now()) {
+				// Session expired.
+				datastore.Delete(s.ctx, key) // Omitting error check...
+				return nil
+			}
+			var sess_ sessionImpl
+			if err = s.codec.Unmarshal(e.Value, &sess_); err != nil {
+				break // Invalid data in stored session entity...
+			}
+			sess = &sess_
+			break
+		}
+	}
+
+	if sess == nil {
+		s.ctx.Errorf("Failed to get session from datastore, id: %s, error: %v", id, err)
+		return nil
+	}
+
+	// Yes! We have it! "Actualize" it.
+	sess.Access()
+	// Mutex is not marshalled, so create a new one:
+	sess.mux = &sync.RWMutex{}
+	s.sessions[id] = sess
+	return sess
+}
+
+// Add is to implement Store.Add().
+func (s *memcacheStore) Add(sess Session) {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	if s.setMemcacheSession(sess) {
+		s.ctx.Infof("Session added: %s", sess.ID())
+		s.sessions[sess.ID()] = sess
+		return
+	}
+}
+
+// setMemcacheSession sets the specified session in the Memcache.
+func (s *memcacheStore) setMemcacheSession(sess Session) (success bool) {
+	item := &memcache.Item{
+		Key:        s.keyPrefix + sess.ID(),
+		Object:     sess,
+		Expiration: sess.Timeout(),
+	}
+
+	var err error
+	for i := 0; i < s.retries; i++ {
+		if err = s.codec.Set(s.ctx, item); err == nil {
+			return true
+		}
+	}
+
+	s.ctx.Errorf("Failed to add session to memcache, id: %s, error: %v", sess.ID(), err)
+	return false
+}
+
+// Remove is to implement Store.Remove().
+func (s *memcacheStore) Remove(sess Session) {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	var err error
+	for i := 0; i < s.retries; i++ {
+		if err = memcache.Delete(s.ctx, s.keyPrefix+sess.ID()); err == nil || err == memcache.ErrCacheMiss {
+			s.ctx.Infof("Session removed: %s", sess.ID())
+			delete(s.sessions, sess.ID())
+			if !s.onlyMemcache {
+				// Also from the Datastore:
+				key := datastore.NewKey(s.ctx, s.dsEntityName, sess.ID(), 0, nil)
+				datastore.Delete(s.ctx, key) // Omitting error check...
+			}
+			return
+		}
+	}
+	s.ctx.Errorf("Failed to remove session from memcache, id: %s, error: %v", sess.ID(), err)
+}
+
+// Close is to implement Store.Close().
+func (s *memcacheStore) Close() {
+	// Flush out sessions that were accessed from this store. No need locking, we're closing...
+	// We could use Cocec.SetMulti(), but sessions will contain at most 1 session like all the times.
+	for _, sess := range s.sessions {
+		s.setMemcacheSession(sess)
+	}
+
+	if s.onlyMemcache {
+		return // Don't save to Datastore
+	}
+
+	if s.asyncDatastoreSave {
+		go s.saveToDatastore()
+	} else {
+		s.saveToDatastore()
+	}
+}
+
+// saveToDatastore saves the sessions of the Store to the Datastore
+// in the caller's goroutine.
+func (s *memcacheStore) saveToDatastore() {
+	// Save sessions that were accessed from this store. No need locking, we're closing...
+	// We could use datastore.PutMulti(), but sessions will contain at most 1 session like all the times.
+	for _, sess := range s.sessions {
+		value, err := s.codec.Marshal(sess)
+		if err != nil {
+			s.ctx.Errorf("Failed to marshal session: %s, error: %v", sess.ID(), err)
+			continue
+		}
+		e := SessEntity{
+			Expires: sess.Accessed().Add(sess.Timeout()),
+			Value:   value,
+		}
+		key := datastore.NewKey(s.ctx, s.dsEntityName, sess.ID(), 0, nil)
+		for i := 0; i < s.retries; i++ {
+			if _, err = datastore.Put(s.ctx, key, &e); err == nil {
+				break
+			}
+		}
+		if err != nil {
+			s.ctx.Errorf("Failed to save session to datastore: %s, error: %v", sess.ID(), err)
+		}
+	}
+}
+
+// PurgeExpiredSessFromDSFunc returns a request handler function which deletes expired sessions
+// from the Datastore.
+// dsEntityName is the name of the entity used for saving sessions; pass an empty string
+// to use the default value (which is "sess_").
+//
+// It is recommended to register the returned handler function to a path which then can be defined
+// as a cron job to be called periodically, e.g. in every 30 minutes or so (your choice).
+// As cron handlers may run up to 10 minutes, the returned handler will stop at 8 minutes
+// to complete safely even if there are more expired, undeleted sessions.
+//
+// The response of the handler func is a JSON text telling if the handler was able to delete all expired sessions,
+// or that it was finished early due to the time. Examle of a respone where all expired sessions were deleted:
+//
+//     {"completed":true}
+func PurgeExpiredSessFromDSFunc(dsEntityName string) http.HandlerFunc {
+	if dsEntityName == "" {
+		dsEntityName = defaultDSEntityName
+	}
+
+	return func(w http.ResponseWriter, r *http.Request) {
+		c := appengine.NewContext(r)
+		// Delete in batches of 100
+		q := datastore.NewQuery(dsEntityName).Filter("exp<", time.Now()).KeysOnly().Limit(100)
+
+		deadline := time.Now().Add(time.Minute * 8)
+
+		for {
+			var err error
+			var keys []*datastore.Key
+
+			if keys, err = q.GetAll(c, nil); err != nil {
+				// Datastore error.
+				c.Errorf("Failed to query expired sessions: %v", err)
+				http.Error(w, "Failed to query expired sessions!", http.StatusInternalServerError)
+			}
+			if len(keys) == 0 {
+				// We're done, no more expired sessions
+				w.Header().Set("Content-Type", "application/json")
+				w.Write([]byte(`{"completed":true}`))
+				return
+			}
+
+			if err = datastore.DeleteMulti(c, keys); err != nil {
+				c.Errorf("Error while deleting expired sessions: %v", err)
+			}
+
+			if time.Now().After(deadline) {
+				// Our time is up, return
+				w.Header().Set("Content-Type", "application/json")
+				w.Write([]byte(`{"completed":false}`))
+				return
+			}
+			// We have time to continue
+		}
+	}
+}

vendor/github.com/icza/session/global.go

@@ -0,0 +1,39 @@
+/*
+
+A global session Manager and delegator functions - for easy to use.
+
+*/
+
+package session
+
+import (
+	"net/http"
+)
+
+// Global is the default session Manager to which the top-level functions such as Get, Add, Remove and Close
+// are wrappers of Manager.
+// You may replace this and keep using the top-level functions, but if you intend to do so,
+// you should close it first with Global.Close().
+var Global = NewCookieManager(NewInMemStore())
+
+// Get delegates to Global.Get(); returns the session specified by the HTTP request.
+// nil is returned if the request does not contain a session, or the contained session is not know by this manager.
+func Get(r *http.Request) Session {
+	return Global.Get(r)
+}
+
+// Add delegates to Global.Add(); adds the session to the HTTP response.
+// This means to let the client know about the specified session by including the sesison id in the response somehow.
+func Add(sess Session, w http.ResponseWriter) {
+	Global.Add(sess, w)
+}
+
+// Remove delegates to Global.Remove(); removes the session from the HTTP response.
+func Remove(sess Session, w http.ResponseWriter) {
+	Global.Remove(sess, w)
+}
+
+// Close delegates to Global.Close(); closes the session manager, releasing any resources that were allocated.
+func Close() {
+	Global.Close()
+}

vendor/github.com/icza/session/inmem_store.go

@@ -0,0 +1,145 @@
+/*
+
+An in-memory session store implementation.
+
+*/
+
+package session
+
+import (
+	"log"
+	"sync"
+	"time"
+)
+
+// In-memory session Store implementation.
+type inMemStore struct {
+	sessions    map[string]Session // Map of sessions (mapped from ID)
+	mux         *sync.RWMutex      // mutex to synchronize access to sessions
+	ticker      *time.Ticker       // Ticker for the session cleaner
+	closeTicker chan struct{}      // Channel to signal close for the session cleaner
+}
+
+// InMemStoreOptions defines options that may be passed when creating a new in-memory Store.
+// All fields are optional; default value will be used for any field that has the zero value.
+type InMemStoreOptions struct {
+	// Session cleaner check interval, default is 10 seconds.
+	SessCleanerInterval time.Duration
+}
+
+// Pointer to zero value of InMemStoreOptions to be reused for efficiency.
+var zeroInMemStoreOptions = new(InMemStoreOptions)
+
+// NewInMemStore returns a new, in-memory session Store with the default options.
+// Default values of options are listed in the InMemStoreOptions type.
+// The returned Store has an automatic session cleaner which runs
+// in its own goroutine.
+func NewInMemStore() Store {
+	return NewInMemStoreOptions(zeroInMemStoreOptions)
+}
+
+// NewInMemStoreOptions returns a new, in-memory session Store with the specified options.
+// The returned Store has an automatic session cleaner which runs
+// in its own goroutine.
+func NewInMemStoreOptions(o *InMemStoreOptions) Store {
+	s := &inMemStore{
+		sessions:    make(map[string]Session),
+		mux:         &sync.RWMutex{},
+		closeTicker: make(chan struct{}),
+	}
+
+	interval := o.SessCleanerInterval
+	if interval == 0 {
+		interval = 10 * time.Second
+	}
+
+	go s.sessCleaner(interval)
+
+	return s
+}
+
+// sessCleaner periodically checks whether sessions have timed out
+// in an endless loop. If a session has timed out, removes it.
+// This method is to be started as a new goroutine.
+func (s *inMemStore) sessCleaner(interval time.Duration) {
+	ticker := time.NewTicker(interval)
+
+	for {
+		select {
+		case <-s.closeTicker:
+			// We are being shut down...
+			ticker.Stop()
+			return
+		case now := <-ticker.C:
+			// Do a sweep.
+			// Remove is very rare compared to the number of checks, so:
+			// "Quick" check with read-lock to see if there's anything to remove:
+			// Note: Session.Access() is called with s.mux, the same mutex we use
+			// when looking for timed-out sessions, so we're good.
+			needRemove := func() bool {
+				s.mux.RLock() // Read lock is enough
+				defer s.mux.RUnlock()
+
+				for _, sess := range s.sessions {
+					if now.Sub(sess.Accessed()) > sess.Timeout() {
+						return true
+					}
+				}
+				return false
+			}()
+			if !needRemove {
+				continue
+			}
+
+			// Remove required:
+			func() {
+				s.mux.Lock() // Read-write lock required
+				defer s.mux.Unlock()
+
+				for _, sess := range s.sessions {
+					if now.Sub(sess.Accessed()) > sess.Timeout() {
+						log.Println("Session timed out:", sess.ID())
+						delete(s.sessions, sess.ID())
+					}
+				}
+			}()
+		}
+	}
+}
+
+// Get is to implement Store.Get().
+func (s *inMemStore) Get(id string) Session {
+	s.mux.RLock()
+	defer s.mux.RUnlock()
+
+	sess := s.sessions[id]
+	if sess == nil {
+		return nil
+	}
+
+	sess.Access()
+	return sess
+}
+
+// Add is to implement Store.Add().
+func (s *inMemStore) Add(sess Session) {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	log.Println("Session added:", sess.ID())
+	s.sessions[sess.ID()] = sess
+}
+
+// Remove is to implement Store.Remove().
+func (s *inMemStore) Remove(sess Session) {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	log.Println("Session removed:", sess.ID())
+	delete(s.sessions, sess.ID())
+}
+
+// Close is to implement Store.Close().
+func (s *inMemStore) Close() {
+	close(s.closeTicker)
+}

vendor/github.com/icza/session/manager.go

@@ -0,0 +1,31 @@
+/*
+
+Session Manager interface.
+
+*/
+
+package session
+
+import (
+	"net/http"
+)
+
+// Manager is a session manager interface.
+// A session manager is responsible to acquire a Session from an (incoming) HTTP request,
+// and to add a Session to an HTTP response to let the client know about the session.
+// A Manager has a backing Store which is responsible to manage Session values at server side.
+type Manager interface {
+	// Get returns the session specified by the HTTP request.
+	// nil is returned if the request does not contain a session, or the contained session is not know by this manager.
+	Get(r *http.Request) Session
+
+	// Add adds the session to the HTTP response.
+	// This means to let the client know about the specified session by including the sesison id in the response somehow.
+	Add(sess Session, w http.ResponseWriter)
+
+	// Remove removes the session from the HTTP response.
+	Remove(sess Session, w http.ResponseWriter)
+
+	// Close closes the session manager, releasing any resources that were allocated.
+	Close()
+}

vendor/github.com/icza/session/session.go

@@ -0,0 +1,231 @@
+/*
+
+Session interface and its implementation.
+
+*/
+
+package session
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+	"io"
+	"sync"
+	"time"
+)
+
+// Session is the (HTTP) session interface.
+// We can use it to store and retrieve constant and variable attributes from it.
+type Session interface {
+	// ID returns the id of the session.
+	ID() string
+
+	// New tells if the session is new.
+	// Implementation is based on whether created and access times are equal.
+	New() bool
+
+	// CAttr returns the value of an attribute provided at session creation.
+	// These attributes cannot be changes during the lifetime of a session,
+	// so they can be accessed safely without synchronization. Exampe is storing the
+	// authenticated user.
+	CAttr(name string) interface{}
+
+	// Attr returns the value of an attribute stored in the session.
+	// Safe for concurrent use.
+	Attr(name string) interface{}
+
+	// SetAttr sets the value of an attribute stored in the session.
+	// Pass the nil value to delete the attribute.
+	// Safe for concurrent use.
+	SetAttr(name string, value interface{})
+
+	// Attrs returns a copy of all the attribute values stored in the session.
+	// Safe for concurrent use.
+	Attrs() map[string]interface{}
+
+	// Created returns the session creation time.
+	Created() time.Time
+
+	// Accessed returns the time when the session was last accessed.
+	Accessed() time.Time
+
+	// Timeout returns the session timeout.
+	// A session may be removed automatically if it is not accessed for this duration.
+	Timeout() time.Duration
+
+	// Mutex returns the RW mutex of the session.
+	// It is used to synchronize access/modification of the state stored in the session.
+	// It can be used if session-level synchronization is required.
+	// Important! If Session values are marshalled / unmarshalled
+	// (e.g. multi server instance environment such as Google AppEngine),
+	// this mutex may be different for each Session value and thus
+	// it can only be used to session-value level synchronization!
+	Mutex() *sync.RWMutex
+
+	// Access registers an access to the session,
+	// updates its last accessed time to the current time.
+	// Users do not need to call this as the session store is responsible for that.
+	Access()
+}
+
+// Session implementation.
+// Fields are exported so a session may be marshalled / unmarshalled.
+type sessionImpl struct {
+	IDF       string                 // ID of the session
+	CreatedF  time.Time              // Creation time
+	AccessedF time.Time              // Last accessed time
+	CAttrsF   map[string]interface{} // Constant attributes specified at session creation
+	AttrsF    map[string]interface{} // Attributes stored in the session
+	TimeoutF  time.Duration          // Session timeout
+	mux       *sync.RWMutex          // RW mutex to synchronize session state access
+}
+
+// SessOptions defines options that may be passed when creating a new Session.
+// All fields are optional; default value will be used for any field that has the zero value.
+type SessOptions struct {
+	// Constant attributes of the session. These be will available via the Session.CAttr() method, without synchronization.
+	// Values from the map will be copied, and will be available via Session.CAttr().
+	CAttrs map[string]interface{}
+
+	// Initial, non-constant attributes to be stored in the session.
+	// Values from the map will be copied, and will be available via Session.Attr() and Session.Attrs,
+	// and may be changed with Session.SetAttr().
+	Attrs map[string]interface{}
+
+	// Session timeout, default is 30 minutes.
+	Timeout time.Duration
+
+	// Byte-length of the information that builds up the session ids.
+	// Using Base-64 encoding, id length will be this multiplied by 4/3 chars.
+	// Default value is 18 (which means length of ID will be 24 chars).
+	IDLength int
+}
+
+// Pointer to zero value of SessOptions to be reused for efficiency.
+var zeroSessOptions = new(SessOptions)
+
+// NewSession creates a new Session with the default options.
+// Default values of options are listed in the SessOptions type.
+func NewSession() Session {
+	return NewSessionOptions(zeroSessOptions)
+}
+
+// NewSessionOptions creates a new Session with the specified options.
+func NewSessionOptions(o *SessOptions) Session {
+	now := time.Now()
+	idLength := o.IDLength
+	if idLength <= 0 {
+		idLength = 18
+	}
+	timeout := o.Timeout
+	if timeout == 0 {
+		timeout = 30 * time.Minute
+	}
+
+	sess := sessionImpl{
+		IDF:       genID(idLength),
+		CreatedF:  now,
+		AccessedF: now,
+		AttrsF:    make(map[string]interface{}),
+		TimeoutF:  timeout,
+		mux:       &sync.RWMutex{},
+	}
+
+	if len(o.CAttrs) > 0 {
+		sess.CAttrsF = make(map[string]interface{}, len(o.CAttrs))
+		for k, v := range o.CAttrs {
+			sess.CAttrsF[k] = v
+		}
+	}
+
+	for k, v := range o.Attrs {
+		sess.AttrsF[k] = v
+	}
+
+	return &sess
+}
+
+// genID generates a secure, random session id using the crypto/rand package.
+func genID(length int) string {
+	r := make([]byte, length)
+	io.ReadFull(rand.Reader, r)
+	return base64.URLEncoding.EncodeToString(r)
+}
+
+// ID is to implement Session.ID().
+func (s *sessionImpl) ID() string {
+	return s.IDF
+}
+
+// New is to implement Session.New().
+func (s *sessionImpl) New() bool {
+	return s.CreatedF == s.AccessedF
+}
+
+// CAttr is to implement Session.CAttr().
+func (s *sessionImpl) CAttr(name string) interface{} {
+	return s.CAttrsF[name]
+}
+
+// Attr is to implement Session.Attr().
+func (s *sessionImpl) Attr(name string) interface{} {
+	s.mux.RLock()
+	defer s.mux.RUnlock()
+
+	return s.AttrsF[name]
+}
+
+// SetAttr is to implement Session.SetAttr().
+func (s *sessionImpl) SetAttr(name string, value interface{}) {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	if value == nil {
+		delete(s.AttrsF, name)
+	} else {
+		s.AttrsF[name] = value
+	}
+}
+
+// Attrs is to implement Session.Attrs().
+func (s *sessionImpl) Attrs() map[string]interface{} {
+	s.mux.RLock()
+	defer s.mux.RUnlock()
+
+	m := make(map[string]interface{}, len(s.AttrsF))
+	for k, v := range s.AttrsF {
+		m[k] = v
+	}
+	return m
+}
+
+// Created is to implement Session.Created().
+func (s *sessionImpl) Created() time.Time {
+	return s.CreatedF
+}
+
+// Accessed is to implement Session.Accessed().
+func (s *sessionImpl) Accessed() time.Time {
+	s.mux.RLock()
+	defer s.mux.RUnlock()
+
+	return s.AccessedF
+}
+
+// Timeout is to implement Session.Timeout().
+func (s *sessionImpl) Timeout() time.Duration {
+	return s.TimeoutF
+}
+
+// Mutex is to implement Session.Mutex().
+func (s *sessionImpl) Mutex() *sync.RWMutex {
+	return s.mux
+}
+
+// Access is to implement Session.Access().
+func (s *sessionImpl) Access() {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	s.AccessedF = time.Now()
+}

vendor/github.com/icza/session/store.go

@@ -0,0 +1,25 @@
+/*
+
+Session Store interface.
+
+*/
+
+package session
+
+// Store is a session store interface.
+// A session store is responsible to store sessions and make them retrievable by their IDs at the server side.
+type Store interface {
+	// Get returns the session specified by its id.
+	// The returned session will have an updated access time (set to the current time).
+	// nil is returned if this store does not contain a session with the specified id.
+	Get(id string) Session
+
+	// Add adds a new session to the store.
+	Add(sess Session)
+
+	// Remove removes a session from the store.
+	Remove(sess Session)
+
+	// Close closes the session store, releasing any resources that were allocated.
+	Close()
+}

vendor/github.com/justinas/nosurf/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Justinas Stankevicius
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/justinas/nosurf/README.md

@@ -0,0 +1,125 @@
+# nosurf
+
+[![Build Status](https://travis-ci.org/justinas/nosurf.svg?branch=master)](https://travis-ci.org/justinas/nosurf)
+[![GoDoc](http://godoc.org/github.com/justinas/nosurf?status.png)](http://godoc.org/github.com/justinas/nosurf)
+
+`nosurf` is an HTTP package for Go
+that helps you prevent Cross-Site Request Forgery attacks.
+It acts like a middleware and therefore 
+is compatible with basically any Go HTTP application.
+
+### Why?
+Even though CSRF is a prominent vulnerability,
+Go's web-related package infrastructure mostly consists of
+micro-frameworks that neither do implement CSRF checks,
+nor should they.
+
+`nosurf` solves this problem by providing a `CSRFHandler`
+that wraps your `http.Handler` and checks for CSRF attacks
+on every non-safe (non-GET/HEAD/OPTIONS/TRACE) method.
+
+`nosurf` requires Go 1.1 or later.
+
+### Features
+
+* Supports any `http.Handler` (frameworks, your own handlers, etc.)
+and acts like one itself.
+* Allows exempting specific endpoints from CSRF checks by
+an exact URL, a glob, or a regular expression.
+* Allows specifying your own failure handler. 
+Want to present the hacker with an ASCII middle finger
+instead of the plain old `HTTP 400`? No problem.
+* Uses masked tokens to mitigate the BREACH attack.
+* Has no dependencies outside the Go standard library.
+
+### Example
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/justinas/nosurf"
+	"html/template"
+	"net/http"
+)
+
+var templateString string = `
+<!doctype html>
+<html>
+<body>
+{{ if .name }}
+<p>Your name: {{ .name }}</p>
+{{ end }}
+<form action="/" method="POST">
+<input type="text" name="name">
+
+<!-- Try removing this or changing its value
+     and see what happens -->
+<input type="hidden" name="csrf_token" value="{{ .token }}">
+<input type="submit" value="Send">
+</form>
+</body>
+</html>
+`
+var templ = template.Must(template.New("t1").Parse(templateString))
+
+func myFunc(w http.ResponseWriter, r *http.Request) {
+	context := make(map[string]string)
+	context["token"] = nosurf.Token(r)
+	if r.Method == "POST" {
+		context["name"] = r.FormValue("name")
+	}
+	
+	templ.Execute(w, context)
+}
+
+func main() {
+	myHandler := http.HandlerFunc(myFunc)
+	fmt.Println("Listening on http://127.0.0.1:8000/")
+	http.ListenAndServe(":8000", nosurf.New(myHandler))
+}
+```
+
+### Manual token verification
+In some cases the CSRF token may be send through a non standard way,
+e.g. a body or request is a JSON encoded message with one of the fields
+being a token.
+
+In such case the handler(path) should be excluded from an automatic
+verification by using one of the exemption methods:
+
+```go
+	func (h *CSRFHandler) ExemptFunc(fn func(r *http.Request) bool)
+	func (h *CSRFHandler) ExemptGlob(pattern string)
+	func (h *CSRFHandler) ExemptGlobs(patterns ...string)
+	func (h *CSRFHandler) ExemptPath(path string)
+	func (h *CSRFHandler) ExemptPaths(paths ...string)
+	func (h *CSRFHandler) ExemptRegexp(re interface{})
+	func (h *CSRFHandler) ExemptRegexps(res ...interface{})
+```
+
+Later on, the token **must** be verified by manually getting the token from the cookie
+and providing the token sent in body through: `VerifyToken(tkn, tkn2 string) bool`.
+
+Example:
+```go
+func HandleJson(w http.ResponseWriter, r *http.Request) {
+	d := struct{
+		X,Y int
+		Tkn string
+	}{}
+	json.Unmarshal(ioutil.ReadAll(r.Body), &d)
+	if !nosurf.VerifyToken(Token(r), d.Tkn) {
+		http.Errorf(w, "CSRF token incorrect", http.StatusBadRequest)
+		return
+	}
+	// do smth cool
+}
+```
+
+### Contributing
+
+0. Find an issue that bugs you / open a new one.
+1. Discuss.
+2. Branch off, commit, test.
+3. Make a pull request / attach the commits to the issue.

vendor/github.com/justinas/nosurf/context.go

@@ -0,0 +1,60 @@
+// +build go1.7
+
+package nosurf
+
+import "net/http"
+
+type ctxKey int
+
+const (
+	nosurfKey ctxKey = iota
+)
+
+type csrfContext struct {
+	// The masked, base64 encoded token
+	// That's suitable for use in form fields, etc.
+	token string
+	// reason for the failure of CSRF check
+	reason error
+}
+
+// Token takes an HTTP request and returns
+// the CSRF token for that request
+// or an empty string if the token does not exist.
+//
+// Note that the token won't be available after
+// CSRFHandler finishes
+// (that is, in another handler that wraps it,
+// or after the request has been served)
+func Token(req *http.Request) string {
+	ctx := req.Context().Value(nosurfKey).(*csrfContext)
+
+	return ctx.token
+}
+
+// Reason takes an HTTP request and returns
+// the reason of failure of the CSRF check for that request
+//
+// Note that the same availability restrictions apply for Reason() as for Token().
+func Reason(req *http.Request) error {
+	ctx := req.Context().Value(nosurfKey).(*csrfContext)
+
+	return ctx.reason
+}
+
+func ctxClear(_ *http.Request) {
+}
+
+func ctxSetToken(req *http.Request, token []byte) {
+	ctx := req.Context().Value(nosurfKey).(*csrfContext)
+	ctx.token = b64encode(maskToken(token))
+}
+
+func ctxSetReason(req *http.Request, reason error) {
+	ctx := req.Context().Value(nosurfKey).(*csrfContext)
+	if ctx.token == "" {
+		panic("Reason should never be set when there's no token in the context yet.")
+	}
+
+	ctx.reason = reason
+}

vendor/github.com/justinas/nosurf/context_legacy.go

@@ -0,0 +1,101 @@
+// +build !go1.7
+
+package nosurf
+
+import (
+	"net/http"
+	"sync"
+)
+
+// This file implements a context similar to one found
+// in gorilla/context, but tailored specifically for our use case
+// and not using gorilla's package just because.
+
+type csrfContext struct {
+	// The masked, base64 encoded token
+	// That's suitable for use in form fields, etc.
+	token string
+	// reason for the failure of CSRF check
+	reason error
+}
+
+var (
+	contextMap = make(map[*http.Request]*csrfContext)
+	cmMutex    = new(sync.RWMutex)
+)
+
+// Token() takes an HTTP request and returns
+// the CSRF token for that request
+// or an empty string if the token does not exist.
+//
+// Note that the token won't be available after
+// CSRFHandler finishes
+// (that is, in another handler that wraps it,
+// or after the request has been served)
+func Token(req *http.Request) string {
+	cmMutex.RLock()
+	defer cmMutex.RUnlock()
+
+	ctx, ok := contextMap[req]
+
+	if !ok {
+		return ""
+	}
+
+	return ctx.token
+}
+
+// Reason() takes an HTTP request and returns
+// the reason of failure of the CSRF check for that request
+//
+// Note that the same availability restrictions apply for Reason() as for Token().
+func Reason(req *http.Request) error {
+	cmMutex.RLock()
+	defer cmMutex.RUnlock()
+
+	ctx, ok := contextMap[req]
+
+	if !ok {
+		return nil
+	}
+
+	return ctx.reason
+}
+
+// Takes a raw token, masks it with a per-request key,
+// encodes in base64 and makes it available to the wrapped handler
+func ctxSetToken(req *http.Request, token []byte) *http.Request {
+	cmMutex.Lock()
+	defer cmMutex.Unlock()
+
+	ctx, ok := contextMap[req]
+	if !ok {
+		ctx = new(csrfContext)
+		contextMap[req] = ctx
+	}
+
+	ctx.token = b64encode(maskToken(token))
+
+	return req
+}
+
+func ctxSetReason(req *http.Request, reason error) *http.Request {
+	cmMutex.Lock()
+	defer cmMutex.Unlock()
+
+	ctx, ok := contextMap[req]
+	if !ok {
+		panic("Reason should never be set when there's no token" +
+			" (context) yet.")
+	}
+
+	ctx.reason = reason
+	return req
+}
+
+func ctxClear(req *http.Request) {
+	cmMutex.Lock()
+	defer cmMutex.Unlock()
+
+	delete(contextMap, req)
+}

vendor/github.com/justinas/nosurf/crypto.go

@@ -0,0 +1,54 @@
+package nosurf
+
+import (
+	"crypto/rand"
+	"io"
+)
+
+// Masks/unmasks the given data *in place*
+// with the given key
+// Slices must be of the same length, or oneTimePad will panic
+func oneTimePad(data, key []byte) {
+	n := len(data)
+	if n != len(key) {
+		panic("Lengths of slices are not equal")
+	}
+
+	for i := 0; i < n; i++ {
+		data[i] ^= key[i]
+	}
+}
+
+func maskToken(data []byte) []byte {
+	if len(data) != tokenLength {
+		return nil
+	}
+
+	// tokenLength*2 == len(enckey + token)
+	result := make([]byte, 2*tokenLength)
+	// the first half of the result is the OTP
+	// the second half is the masked token itself
+	key := result[:tokenLength]
+	token := result[tokenLength:]
+	copy(token, data)
+
+	// generate the random token
+	if _, err := io.ReadFull(rand.Reader, key); err != nil {
+		panic(err)
+	}
+
+	oneTimePad(token, key)
+	return result
+}
+
+func unmaskToken(data []byte) []byte {
+	if len(data) != tokenLength*2 {
+		return nil
+	}
+
+	key := data[:tokenLength]
+	token := data[tokenLength:]
+	oneTimePad(token, key)
+
+	return token
+}

vendor/github.com/justinas/nosurf/exempt.go

@@ -0,0 +1,108 @@
+package nosurf
+
+import (
+	"fmt"
+	"net/http"
+	pathModule "path"
+	"reflect"
+	"regexp"
+)
+
+// Checks if the given request is exempt from CSRF checks.
+// It checks the ExemptFunc first, then the exact paths,
+// then the globs and finally the regexps.
+func (h *CSRFHandler) IsExempt(r *http.Request) bool {
+	if h.exemptFunc != nil && h.exemptFunc(r) {
+		return true
+	}
+
+	path := r.URL.Path
+	if sContains(h.exemptPaths, path) {
+		return true
+	}
+
+	// then the globs
+	for _, glob := range h.exemptGlobs {
+		matched, err := pathModule.Match(glob, path)
+		if matched && err == nil {
+			return true
+		}
+	}
+
+	// finally, the regexps
+	for _, re := range h.exemptRegexps {
+		if re.MatchString(path) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Exempts an exact path from CSRF checks
+// With this (and other Exempt* methods)
+// you should take note that Go's paths
+// include a leading slash.
+func (h *CSRFHandler) ExemptPath(path string) {
+	h.exemptPaths = append(h.exemptPaths, path)
+}
+
+// A variadic argument version of ExemptPath()
+func (h *CSRFHandler) ExemptPaths(paths ...string) {
+	for _, v := range paths {
+		h.ExemptPath(v)
+	}
+}
+
+// Exempts URLs that match the specified glob pattern
+// (as used by filepath.Match()) from CSRF checks
+//
+// Note that ExemptGlob() is unable to detect syntax errors,
+// because it doesn't have a path to check it against
+// and filepath.Match() doesn't report an error
+// if the path is empty.
+// If we find a way to check the syntax, ExemptGlob
+// MIGHT PANIC on a syntax error in the future.
+// ALWAYS check your globs for syntax errors.
+func (h *CSRFHandler) ExemptGlob(pattern string) {
+	h.exemptGlobs = append(h.exemptGlobs, pattern)
+}
+
+// A variadic argument version of ExemptGlob()
+func (h *CSRFHandler) ExemptGlobs(patterns ...string) {
+	for _, v := range patterns {
+		h.ExemptGlob(v)
+	}
+}
+
+// Accepts a regular expression string or a compiled *regexp.Regexp
+// and exempts URLs that match it from CSRF checks.
+//
+// If the given argument is neither of the accepted values,
+// or the given string fails to compile, ExemptRegexp() panics.
+func (h *CSRFHandler) ExemptRegexp(re interface{}) {
+	var compiled *regexp.Regexp
+
+	switch re.(type) {
+	case string:
+		compiled = regexp.MustCompile(re.(string))
+	case *regexp.Regexp:
+		compiled = re.(*regexp.Regexp)
+	default:
+		err := fmt.Sprintf("%v isn't a valid type for ExemptRegexp()", reflect.TypeOf(re))
+		panic(err)
+	}
+
+	h.exemptRegexps = append(h.exemptRegexps, compiled)
+}
+
+// A variadic argument version of ExemptRegexp()
+func (h *CSRFHandler) ExemptRegexps(res ...interface{}) {
+	for _, v := range res {
+		h.ExemptRegexp(v)
+	}
+}
+
+func (h *CSRFHandler) ExemptFunc(fn func(r *http.Request) bool) {
+	h.exemptFunc = fn
+}

vendor/github.com/justinas/nosurf/handler.go

@@ -0,0 +1,220 @@
+// Package nosurf implements an HTTP handler that
+// mitigates Cross-Site Request Forgery Attacks.
+package nosurf
+
+import (
+	"errors"
+	"net/http"
+	"net/url"
+	"regexp"
+)
+
+const (
+	// the name of CSRF cookie
+	CookieName = "csrf_token"
+	// the name of the form field
+	FormFieldName = "csrf_token"
+	// the name of CSRF header
+	HeaderName = "X-CSRF-Token"
+	// the HTTP status code for the default failure handler
+	FailureCode = 400
+
+	// Max-Age in seconds for the default base cookie. 365 days.
+	MaxAge = 365 * 24 * 60 * 60
+)
+
+var safeMethods = []string{"GET", "HEAD", "OPTIONS", "TRACE"}
+
+// reasons for CSRF check failures
+var (
+	ErrNoReferer  = errors.New("A secure request contained no Referer or its value was malformed")
+	ErrBadReferer = errors.New("A secure request's Referer comes from a different Origin" +
+		" from the request's URL")
+	ErrBadToken = errors.New("The CSRF token in the cookie doesn't match the one" +
+		" received in a form/header.")
+)
+
+type CSRFHandler struct {
+	// Handlers that CSRFHandler wraps.
+	successHandler http.Handler
+	failureHandler http.Handler
+
+	// The base cookie that CSRF cookies will be built upon.
+	// This should be a better solution of customizing the options
+	// than a bunch of methods SetCookieExpiration(), etc.
+	baseCookie http.Cookie
+
+	// Slices of paths that are exempt from CSRF checks.
+	// They can be specified by...
+	// ...an exact path,
+	exemptPaths []string
+	// ...a regexp,
+	exemptRegexps []*regexp.Regexp
+	// ...or a glob (as used by path.Match()).
+	exemptGlobs []string
+	// ...or a custom matcher function
+	exemptFunc func(r *http.Request) bool
+
+	// All of those will be matched against Request.URL.Path,
+	// So they should take the leading slash into account
+}
+
+func defaultFailureHandler(w http.ResponseWriter, r *http.Request) {
+	http.Error(w, "", FailureCode)
+}
+
+// Extracts the "sent" token from the request
+// and returns an unmasked version of it
+func extractToken(r *http.Request) []byte {
+	var sentToken string
+
+	// Prefer the header over form value
+	sentToken = r.Header.Get(HeaderName)
+
+	// Then POST values
+	if len(sentToken) == 0 {
+		sentToken = r.PostFormValue(FormFieldName)
+	}
+
+	// If all else fails, try a multipart value.
+	// PostFormValue() will already have called ParseMultipartForm()
+	if len(sentToken) == 0 && r.MultipartForm != nil {
+		vals := r.MultipartForm.Value[FormFieldName]
+		if len(vals) != 0 {
+			sentToken = vals[0]
+		}
+	}
+
+	return b64decode(sentToken)
+}
+
+// Constructs a new CSRFHandler that calls
+// the specified handler if the CSRF check succeeds.
+func New(handler http.Handler) *CSRFHandler {
+	baseCookie := http.Cookie{}
+	baseCookie.MaxAge = MaxAge
+
+	csrf := &CSRFHandler{successHandler: handler,
+		failureHandler: http.HandlerFunc(defaultFailureHandler),
+		baseCookie:     baseCookie,
+	}
+
+	return csrf
+}
+
+// The same as New(), but has an interface return type.
+func NewPure(handler http.Handler) http.Handler {
+	return New(handler)
+}
+
+func (h *CSRFHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	r = addNosurfContext(r)
+	defer ctxClear(r)
+	w.Header().Add("Vary", "Cookie")
+
+	var realToken []byte
+
+	tokenCookie, err := r.Cookie(CookieName)
+	if err == nil {
+		realToken = b64decode(tokenCookie.Value)
+	}
+
+	// If the length of the real token isn't what it should be,
+	// it has either been tampered with,
+	// or we're migrating onto a new algorithm for generating tokens,
+	// or it hasn't ever been set so far.
+	// In any case of those, we should regenerate it.
+	//
+	// As a consequence, CSRF check will fail when comparing the tokens later on,
+	// so we don't have to fail it just yet.
+	if len(realToken) != tokenLength {
+		h.RegenerateToken(w, r)
+	} else {
+		ctxSetToken(r, realToken)
+	}
+
+	if sContains(safeMethods, r.Method) || h.IsExempt(r) {
+		// short-circuit with a success for safe methods
+		h.handleSuccess(w, r)
+		return
+	}
+
+	// if the request is secure, we enforce origin check
+	// for referer to prevent MITM of http->https requests
+	if r.URL.Scheme == "https" {
+		referer, err := url.Parse(r.Header.Get("Referer"))
+
+		// if we can't parse the referer or it's empty,
+		// we assume it's not specified
+		if err != nil || referer.String() == "" {
+			ctxSetReason(r, ErrNoReferer)
+			h.handleFailure(w, r)
+			return
+		}
+
+		// if the referer doesn't share origin with the request URL,
+		// we have another error for that
+		if !sameOrigin(referer, r.URL) {
+			ctxSetReason(r, ErrBadReferer)
+			h.handleFailure(w, r)
+			return
+		}
+	}
+
+	// Finally, we check the token itself.
+	sentToken := extractToken(r)
+
+	if !verifyToken(realToken, sentToken) {
+		ctxSetReason(r, ErrBadToken)
+		h.handleFailure(w, r)
+		return
+	}
+
+	// Everything else passed, handle the success.
+	h.handleSuccess(w, r)
+}
+
+// handleSuccess simply calls the successHandler.
+// Everything else, like setting a token in the context
+// is taken care of by h.ServeHTTP()
+func (h *CSRFHandler) handleSuccess(w http.ResponseWriter, r *http.Request) {
+	h.successHandler.ServeHTTP(w, r)
+}
+
+// Same applies here: h.ServeHTTP() sets the failure reason, the token,
+// and only then calls handleFailure()
+func (h *CSRFHandler) handleFailure(w http.ResponseWriter, r *http.Request) {
+	h.failureHandler.ServeHTTP(w, r)
+}
+
+// Generates a new token, sets it on the given request and returns it
+func (h *CSRFHandler) RegenerateToken(w http.ResponseWriter, r *http.Request) string {
+	token := generateToken()
+	h.setTokenCookie(w, r, token)
+
+	return Token(r)
+}
+
+func (h *CSRFHandler) setTokenCookie(w http.ResponseWriter, r *http.Request, token []byte) {
+	// ctxSetToken() does the masking for us
+	ctxSetToken(r, token)
+
+	cookie := h.baseCookie
+	cookie.Name = CookieName
+	cookie.Value = b64encode(token)
+
+	http.SetCookie(w, &cookie)
+
+}
+
+// Sets the handler to call in case the CSRF check
+// fails. By default it's defaultFailureHandler.
+func (h *CSRFHandler) SetFailureHandler(handler http.Handler) {
+	h.failureHandler = handler
+}
+
+// Sets the base cookie to use when building a CSRF token cookie
+// This way you can specify the Domain, Path, HttpOnly, Secure, etc.
+func (h *CSRFHandler) SetBaseCookie(cookie http.Cookie) {
+	h.baseCookie = cookie
+}

vendor/github.com/justinas/nosurf/handler_go17.go

@@ -0,0 +1,12 @@
+// +build go1.7
+
+package nosurf
+
+import (
+	"context"
+	"net/http"
+)
+
+func addNosurfContext(r *http.Request) *http.Request {
+	return r.WithContext(context.WithValue(r.Context(), nosurfKey, &csrfContext{}))
+}

vendor/github.com/justinas/nosurf/handler_legacy.go

@@ -0,0 +1,9 @@
+// +build !go1.7
+
+package nosurf
+
+import "net/http"
+
+func addNosurfContext(r *http.Request) *http.Request {
+	return r
+}

vendor/github.com/justinas/nosurf/token.go

@@ -0,0 +1,105 @@
+package nosurf
+
+import (
+	"crypto/rand"
+	"crypto/subtle"
+	"encoding/base64"
+	"fmt"
+	"io"
+)
+
+const (
+	tokenLength = 32
+)
+
+/*
+There are two types of tokens.
+
+* The unmasked "real" token consists of 32 random bytes.
+  It is stored in a cookie (base64-encoded) and it's the
+  "reference" value that sent tokens get compared to.
+
+* The masked "sent" token consists of 64 bytes:
+  32 byte key used for one-time pad masking and
+  32 byte "real" token masked with the said key.
+  It is used as a value (base64-encoded as well)
+  in forms and/or headers.
+
+Upon processing, both tokens are base64-decoded
+and then treated as 32/64 byte slices.
+*/
+
+// A token is generated by returning tokenLength bytes
+// from crypto/rand
+func generateToken() []byte {
+	bytes := make([]byte, tokenLength)
+
+	if _, err := io.ReadFull(rand.Reader, bytes); err != nil {
+		panic(err)
+	}
+
+	return bytes
+}
+
+func b64encode(data []byte) string {
+	return base64.StdEncoding.EncodeToString(data)
+}
+
+func b64decode(data string) []byte {
+	decoded, err := base64.StdEncoding.DecodeString(data)
+	if err != nil {
+		return nil
+	}
+	return decoded
+}
+
+// VerifyToken verifies the sent token equals the real one
+// and returns a bool value indicating if tokens are equal.
+// Supports masked tokens. realToken comes from Token(r) and
+// sentToken is token sent unusual way.
+func VerifyToken(realToken, sentToken string) bool {
+	r := b64decode(realToken)
+	if len(r) == 2*tokenLength {
+		r = unmaskToken(r)
+	}
+	s := b64decode(sentToken)
+	if len(s) == 2*tokenLength {
+		s = unmaskToken(s)
+	}
+	return subtle.ConstantTimeCompare(r, s) == 1
+}
+
+func verifyToken(realToken, sentToken []byte) bool {
+	realN := len(realToken)
+	sentN := len(sentToken)
+
+	// sentN == tokenLength means the token is unmasked
+	// sentN == 2*tokenLength means the token is masked.
+
+	if realN == tokenLength && sentN == 2*tokenLength {
+		return verifyMasked(realToken, sentToken)
+	} else {
+		return false
+	}
+}
+
+// Verifies the masked token
+func verifyMasked(realToken, sentToken []byte) bool {
+	sentPlain := unmaskToken(sentToken)
+	return subtle.ConstantTimeCompare(realToken, sentPlain) == 1
+}
+
+func checkForPRNG() {
+	// Check that cryptographically secure PRNG is available
+	// In case it's not, panic.
+	buf := make([]byte, 1)
+	_, err := io.ReadFull(rand.Reader, buf)
+
+	if err != nil {
+		panic(fmt.Sprintf("crypto/rand is unavailable: Read() failed with %#v", err))
+	}
+}
+
+func init() {
+	checkForPRNG()
+}

vendor/github.com/justinas/nosurf/utils.go

@@ -0,0 +1,25 @@
+package nosurf
+
+import (
+	"net/url"
+)
+
+func sContains(slice []string, s string) bool {
+	// checks if the given slice contains the given string
+	for _, v := range slice {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}
+
+// Checks if the given URLs have the same origin
+// (that is, they share the host, the port and the scheme)
+func sameOrigin(u1, u2 *url.URL) bool {
+	// we take pointers, as url.Parse() returns a pointer
+	// and http.Request.URL is a pointer as well
+
+	// Host is either host or host:port
+	return (u1.Scheme == u2.Scheme && u1.Host == u2.Host)
+}

vendor/github.com/kardianos/osext/LICENSE

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

vendor/github.com/kardianos/osext/README.md

@@ -0,0 +1,21 @@
+### Extensions to the "os" package.
+
+[![GoDoc](https://godoc.org/github.com/kardianos/osext?status.svg)](https://godoc.org/github.com/kardianos/osext)
+
+## Find the current Executable and ExecutableFolder.
+
+As of go1.8 the Executable function may be found in `os`. The Executable function
+in the std lib `os` package is used if available.
+
+There is sometimes utility in finding the current executable file
+that is running. This can be used for upgrading the current executable
+or finding resources located relative to the executable file. Both
+working directory and the os.Args[0] value are arbitrary and cannot
+be relied on; os.Args[0] can be "faked".
+
+Multi-platform and supports:
+ * Linux
+ * OS X
+ * Windows
+ * Plan 9
+ * BSDs.

vendor/github.com/kardianos/osext/osext.go

@@ -0,0 +1,33 @@
+// 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.
+
+// Extensions to the standard "os" package.
+package osext // import "github.com/kardianos/osext"
+
+import "path/filepath"
+
+var cx, ce = executableClean()
+
+func executableClean() (string, error) {
+	p, err := executable()
+	return filepath.Clean(p), err
+}
+
+// Executable returns an absolute path that can be used to
+// re-invoke the current program.
+// It may not be valid after the current program exits.
+func Executable() (string, error) {
+	return cx, ce
+}
+
+// Returns same path as Executable, returns just the folder
+// path. Excludes the executable name and any trailing slash.
+func ExecutableFolder() (string, error) {
+	p, err := Executable()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Dir(p), nil
+}

vendor/github.com/kardianos/osext/osext_go18.go

@@ -0,0 +1,9 @@
+//+build go1.8,!openbsd
+
+package osext
+
+import "os"
+
+func executable() (string, error) {
+	return os.Executable()
+}

vendor/github.com/kardianos/osext/osext_plan9.go

@@ -0,0 +1,22 @@
+// 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 !go1.8
+
+package osext
+
+import (
+	"os"
+	"strconv"
+	"syscall"
+)
+
+func executable() (string, error) {
+	f, err := os.Open("/proc/" + strconv.Itoa(os.Getpid()) + "/text")
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+	return syscall.Fd2path(int(f.Fd()))
+}

vendor/github.com/kardianos/osext/osext_procfs.go

@@ -0,0 +1,36 @@
+// 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 !go1.8,linux !go1.8,netbsd !go1.8,solaris !go1.8,dragonfly
+
+package osext
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+)
+
+func executable() (string, error) {
+	switch runtime.GOOS {
+	case "linux":
+		const deletedTag = " (deleted)"
+		execpath, err := os.Readlink("/proc/self/exe")
+		if err != nil {
+			return execpath, err
+		}
+		execpath = strings.TrimSuffix(execpath, deletedTag)
+		execpath = strings.TrimPrefix(execpath, deletedTag)
+		return execpath, nil
+	case "netbsd":
+		return os.Readlink("/proc/curproc/exe")
+	case "dragonfly":
+		return os.Readlink("/proc/curproc/file")
+	case "solaris":
+		return os.Readlink(fmt.Sprintf("/proc/%d/path/a.out", os.Getpid()))
+	}
+	return "", errors.New("ExecPath not implemented for " + runtime.GOOS)
+}

vendor/github.com/kardianos/osext/osext_sysctl.go

@@ -0,0 +1,126 @@
+// 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 !go1.8,darwin !go1.8,freebsd openbsd
+
+package osext
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"syscall"
+	"unsafe"
+)
+
+var initCwd, initCwdErr = os.Getwd()
+
+func executable() (string, error) {
+	var mib [4]int32
+	switch runtime.GOOS {
+	case "freebsd":
+		mib = [4]int32{1 /* CTL_KERN */, 14 /* KERN_PROC */, 12 /* KERN_PROC_PATHNAME */, -1}
+	case "darwin":
+		mib = [4]int32{1 /* CTL_KERN */, 38 /* KERN_PROCARGS */, int32(os.Getpid()), -1}
+	case "openbsd":
+		mib = [4]int32{1 /* CTL_KERN */, 55 /* KERN_PROC_ARGS */, int32(os.Getpid()), 1 /* KERN_PROC_ARGV */}
+	}
+
+	n := uintptr(0)
+	// Get length.
+	_, _, errNum := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 4, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errNum != 0 {
+		return "", errNum
+	}
+	if n == 0 { // This shouldn't happen.
+		return "", nil
+	}
+	buf := make([]byte, n)
+	_, _, errNum = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 4, uintptr(unsafe.Pointer(&buf[0])), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errNum != 0 {
+		return "", errNum
+	}
+	if n == 0 { // This shouldn't happen.
+		return "", nil
+	}
+
+	var execPath string
+	switch runtime.GOOS {
+	case "openbsd":
+		// buf now contains **argv, with pointers to each of the C-style
+		// NULL terminated arguments.
+		var args []string
+		argv := uintptr(unsafe.Pointer(&buf[0]))
+	Loop:
+		for {
+			argp := *(**[1 << 20]byte)(unsafe.Pointer(argv))
+			if argp == nil {
+				break
+			}
+			for i := 0; uintptr(i) < n; i++ {
+				// we don't want the full arguments list
+				if string(argp[i]) == " " {
+					break Loop
+				}
+				if argp[i] != 0 {
+					continue
+				}
+				args = append(args, string(argp[:i]))
+				n -= uintptr(i)
+				break
+			}
+			if n < unsafe.Sizeof(argv) {
+				break
+			}
+			argv += unsafe.Sizeof(argv)
+			n -= unsafe.Sizeof(argv)
+		}
+		execPath = args[0]
+		// There is no canonical way to get an executable path on
+		// OpenBSD, so check PATH in case we are called directly
+		if execPath[0] != '/' && execPath[0] != '.' {
+			execIsInPath, err := exec.LookPath(execPath)
+			if err == nil {
+				execPath = execIsInPath
+			}
+		}
+	default:
+		for i, v := range buf {
+			if v == 0 {
+				buf = buf[:i]
+				break
+			}
+		}
+		execPath = string(buf)
+	}
+
+	var err error
+	// execPath will not be empty due to above checks.
+	// Try to get the absolute path if the execPath is not rooted.
+	if execPath[0] != '/' {
+		execPath, err = getAbs(execPath)
+		if err != nil {
+			return execPath, err
+		}
+	}
+	// For darwin KERN_PROCARGS may return the path to a symlink rather than the
+	// actual executable.
+	if runtime.GOOS == "darwin" {
+		if execPath, err = filepath.EvalSymlinks(execPath); err != nil {
+			return execPath, err
+		}
+	}
+	return execPath, nil
+}
+
+func getAbs(execPath string) (string, error) {
+	if initCwdErr != nil {
+		return execPath, initCwdErr
+	}
+	// The execPath may begin with a "../" or a "./" so clean it first.
+	// Join the two paths, trailing and starting slashes undetermined, so use
+	// the generic Join function.
+	return filepath.Join(initCwd, filepath.Clean(execPath)), nil
+}

vendor/github.com/kardianos/osext/osext_windows.go

@@ -0,0 +1,36 @@
+// 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 !go1.8
+
+package osext
+
+import (
+	"syscall"
+	"unicode/utf16"
+	"unsafe"
+)
+
+var (
+	kernel                = syscall.MustLoadDLL("kernel32.dll")
+	getModuleFileNameProc = kernel.MustFindProc("GetModuleFileNameW")
+)
+
+// GetModuleFileName() with hModule = NULL
+func executable() (exePath string, err error) {
+	return getModuleFileName()
+}
+
+func getModuleFileName() (string, error) {
+	var n uint32
+	b := make([]uint16, syscall.MAX_PATH)
+	size := uint32(len(b))
+
+	r0, _, e1 := getModuleFileNameProc.Call(0, uintptr(unsafe.Pointer(&b[0])), uintptr(size))
+	n = uint32(r0)
+	if n == 0 {
+		return "", e1
+	}
+	return string(utf16.Decode(b[0:n])), nil
+}

vendor/github.com/pressly/chi/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+## v2.0.0 (2017-01-06)
+
+- After many months of v2 being in an RC state with many companies and users running it in
+production, the inclusion of some improvements to the middlewares, we are very pleased to
+announce v2.0.0 of chi.
+
+
+## v2.0.0-rc1 (2016-07-26)
+
+- Huge update! chi v2 is a large refactor targetting Go 1.7+. As of Go 1.7, the popular
+community `"net/context"` package has been included in the standard library as `"context"` and
+utilized by `"net/http"` and `http.Request` to managing deadlines, cancelation signals and other
+request-scoped values. We're very excited about the new context addition and are proud to
+introduce chi v2, a minimal and powerful routing package for building large HTTP services,
+with zero external dependencies. Chi focuses on idiomatic design and encourages the use of 
+stdlib HTTP handlers and middlwares.
+- chi v2 deprecates its `chi.Handler` interface and requires `http.Handler` or `http.HandlerFunc`
+- chi v2 stores URL routing parameters and patterns in the standard request context: `r.Context()`
+- chi v2 lower-level routing context is accessible by `chi.RouteContext(r.Context()) *chi.Context`,
+  which provides direct access to URL routing parameters, the routing path and the matching
+  routing patterns.
+- Users upgrading from chi v1 to v2, need to:
+  1. Update the old chi.Handler signature, `func(ctx context.Context, w http.ResponseWriter, r *http.Request)` to
+     the standard http.Handler: `func(w http.ResponseWriter, r *http.Request)`
+  2. Use `chi.URLParam(r *http.Request, paramKey string) string`
+     or `URLParamFromCtx(ctx context.Context, paramKey string) string` to access a url parameter value
+
+
+## v1.0.0 (2016-07-01)
+
+- Released chi v1 stable https://github.com/pressly/chi/tree/v1.0.0 for Go 1.6 and older.
+
+
+## v0.9.0 (2016-03-31)
+
+- Reuse context objects via sync.Pool for zero-allocation routing [#33](https://github.com/pressly/chi/pull/33)
+- BREAKING NOTE: due to subtle API changes, previously `chi.URLParams(ctx)["id"]` used to access url parameters
+  has changed to: `chi.URLParam(ctx, "id")`

vendor/github.com/pressly/chi/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+# Contributing
+
+## Prerequisites
+
+1. [Install Go][go-install].
+2. Download the sources and switch the working directory:
+
+    ```bash
+    go get -u -d github.com/pressly/chi
+    cd $GOPATH/src/github.com/pressly/chi
+    ```
+
+## Submitting a Pull Request
+
+A typical workflow is:
+
+1. [Fork the repository.][fork] [This tip maybe also helpful.][go-fork-tip]
+2. [Create a topic branch.][branch]
+3. Add tests for your change.
+4. Run `go test`. If your tests pass, return to the step 3.
+5. Implement the change and ensure the steps from the previous step pass.
+6. Run `goimports -w .`, to ensure the new code conforms to Go formatting guideline.
+7. [Add, commit and push your changes.][git-help]
+8. [Submit a pull request.][pull-req]
+
+[go-install]: https://golang.org/doc/install
+[go-fork-tip]: http://blog.campoy.cat/2014/03/github-and-go-forking-pull-requests-and.html
+[fork]: https://help.github.com/articles/fork-a-repo
+[branch]: http://learn.github.com/p/branching.html
+[git-help]: https://guides.github.com
+[pull-req]: https://help.github.com/articles/using-pull-requests

vendor/github.com/pressly/chi/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015-present Peter Kieltyka (https://github.com/pkieltyka)
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/pressly/chi/README.md

@@ -0,0 +1,408 @@
+<img alt="chi" src="https://cdn.rawgit.com/pressly/chi/master/_examples/chi.svg" width="220" />
+===
+
+[![GoDoc Widget]][GoDoc] [![Travis Widget]][Travis]
+
+`chi` is a lightweight, idiomatic and composable router for building Go 1.7+ HTTP services. It's
+especially good at helping you write large REST API services that are kept maintainable as your
+project grows and changes. `chi` is built on the new `context` package introduced in Go 1.7 to
+handle signaling, cancelation and request-scoped values across a handler chain.
+
+The focus of the project has been to seek out an elegant and comfortable design for writing
+REST API servers, written during the development of the Pressly API service that powers our
+public API service, which in turn powers all of our client-side applications.
+
+The key considerations of chi's design are: project structure, maintainability, standard http
+handlers (stdlib-only), developer productivity, and deconstructing a large system into many small
+parts. The core router `github.com/pressly/chi` is quite small (less than 1000 LOC), but we've also
+included some useful/optional subpackages: `middleware`, `render` and `docgen`. We hope you enjoy it too!
+
+## Install
+
+`go get -u github.com/pressly/chi`
+
+
+## Features
+
+* **Lightweight** - cloc'd in <1000 LOC for the chi router
+* **Fast** - yes, see [benchmarks](#benchmarks)
+* **100% compatible with net/http** - use any http or middleware pkg in the ecosystem that is also compat with `net/http`
+* **Designed for modular/composable APIs** - middlewares, inline middlewares, route groups and subrouter mounting
+* **Context control** - built on new `context` package, providing value chaining, cancelations and timeouts
+* **Robust** - tested / used in production at Pressly.com, and many others
+* **Doc generation** - `docgen` auto-generates routing documentation from your source to JSON or Markdown
+* **No external dependencies** - plain ol' Go 1.7+ stdlib + net/http
+
+
+## Examples
+
+* [rest](https://github.com/pressly/chi/blob/master/_examples/rest/main.go) - REST APIs made easy, productive and maintainable
+* [logging](https://github.com/pressly/chi/blob/master/_examples/logging/main.go) - Easy structured logging for any backend
+* [limits](https://github.com/pressly/chi/blob/master/_examples/limits/main.go) - Timeouts and Throttling
+* [todos-resource](https://github.com/pressly/chi/blob/master/_examples/todos-resource/main.go) - Struct routers/handlers, an example of another code layout style
+* [versions](https://github.com/pressly/chi/blob/master/_examples/versions/main.go) - Demo of `chi/render` subpkg
+* [fileserver](https://github.com/pressly/chi/blob/master/_examples/fileserver/main.go) - Easily serve static files
+* [graceful](https://github.com/pressly/chi/blob/master/_examples/graceful/main.go) - Graceful context signaling and server shutdown
+
+
+**As easy as:**
+
+```go
+package main
+
+import (
+	"net/http"
+	"github.com/pressly/chi"
+)
+
+func main() {
+	r := chi.NewRouter()
+	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("welcome"))
+	})
+	http.ListenAndServe(":3000", r)
+}
+```
+
+**REST Preview:**
+
+Here is a little preview of how routing looks like with chi. Also take a look at the generated routing docs
+in JSON ([routes.json](https://github.com/pressly/chi/blob/master/_examples/rest/routes.json)) and in
+Markdown ([routes.md](https://github.com/pressly/chi/blob/master/_examples/rest/routes.md)).
+
+I highly recommend reading the source of the [examples](#examples) listed above, they will show you all the features
+of chi and serve as a good form of documentation.
+
+```go
+import (
+  //...
+  "context"
+  "github.com/pressly/chi"
+  "github.com/pressly/chi/middleware"
+)
+
+func main() {
+  r := chi.NewRouter()
+
+  // A good base middleware stack
+  r.Use(middleware.RequestID)
+  r.Use(middleware.RealIP)
+  r.Use(middleware.Logger)
+  r.Use(middleware.Recoverer)
+
+  // When a client closes their connection midway through a request, the
+  // http.CloseNotifier will cancel the request context (ctx).
+  r.Use(middleware.CloseNotify)
+
+  // Set a timeout value on the request context (ctx), that will signal
+  // through ctx.Done() that the request has timed out and further
+  // processing should be stopped.
+  r.Use(middleware.Timeout(60 * time.Second))
+
+  r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+    w.Write([]byte("hi"))
+  })
+
+  // RESTy routes for "articles" resource
+  r.Route("/articles", func(r chi.Router) {
+    r.With(paginate).Get("/", listArticles)  // GET /articles
+    r.Post("/", createArticle)               // POST /articles
+    r.Get("/search", searchArticles)         // GET /articles/search
+
+    r.Route("/:articleID", func(r chi.Router) {
+      r.Use(ArticleCtx)
+      r.Get("/", getArticle)                 // GET /articles/123
+      r.Put("/", updateArticle)              // PUT /articles/123
+      r.Delete("/", deleteArticle)           // DELETE /articles/123
+    })
+  })
+
+  // Mount the admin sub-router
+  r.Mount("/admin", adminRouter())
+
+  http.ListenAndServe(":3333", r)
+}
+
+func ArticleCtx(next http.Handler) http.Handler {
+  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    articleID := chi.URLParam(r, "articleID")
+    article, err := dbGetArticle(articleID)
+    if err != nil {
+      http.Error(w, http.StatusText(404), 404)
+      return
+    }
+    ctx := context.WithValue(r.Context(), "article", article)
+    next.ServeHTTP(w, r.WithContext(ctx))
+  })
+}
+
+func getArticle(w http.ResponseWriter, r *http.Request) {
+  ctx := r.Context()
+  article, ok := ctx.Value("article").(*Article)
+  if !ok {
+    http.Error(w, http.StatusText(422), 422)
+    return
+  }
+  w.Write([]byte(fmt.Sprintf("title:%s", article.Title)))
+}
+
+// A completely separate router for administrator routes
+func adminRouter() http.Handler {
+  r := chi.NewRouter()
+  r.Use(AdminOnly)
+  r.Get("/", adminIndex)
+  r.Get("/accounts", adminListAccounts)
+  return r
+}
+
+func AdminOnly(next http.Handler) http.Handler {
+  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    ctx := r.Context()
+    perm, ok := ctx.Value("acl.permission").(YourPermissionType)
+    if !ok || !perm.IsAdmin() {
+      http.Error(w, http.StatusText(403), 403)
+      return
+    }
+    next.ServeHTTP(w, r)
+  })
+}
+```
+
+
+## Router design
+
+chi's router is based on a kind of [Patricia Radix trie](https://en.wikipedia.org/wiki/Radix_tree).
+The router is fully compatible with `net/http`.
+
+Built on top of the tree is the `Router` interface:
+
+```go
+// Router consisting of the core routing methods used by chi's Mux,
+// using only the standard net/http.
+type Router interface {
+	http.Handler
+	Routes
+
+	// Use appends one of more middlewares onto the Router stack.
+	Use(middlewares ...func(http.Handler) http.Handler)
+
+	// With adds inline middlewares for an endpoint handler.
+	With(middlewares ...func(http.Handler) http.Handler) Router
+
+	// Group adds a new inline-Router along the current routing
+	// path, with a fresh middleware stack for the inline-Router.
+	Group(fn func(r Router)) Router
+
+	// Route mounts a sub-Router along a `pattern`` string.
+	Route(pattern string, fn func(r Router)) Router
+
+	// Mount attaches another http.Handler along ./pattern/*
+	Mount(pattern string, h http.Handler)
+
+	// Handle and HandleFunc adds routes for `pattern` that matches
+	// all HTTP methods.
+	Handle(pattern string, h http.Handler)
+	HandleFunc(pattern string, h http.HandlerFunc)
+
+	// HTTP-method routing along `pattern`
+	Connect(pattern string, h http.HandlerFunc)
+	Delete(pattern string, h http.HandlerFunc)
+	Get(pattern string, h http.HandlerFunc)
+	Head(pattern string, h http.HandlerFunc)
+	Options(pattern string, h http.HandlerFunc)
+	Patch(pattern string, h http.HandlerFunc)
+	Post(pattern string, h http.HandlerFunc)
+	Put(pattern string, h http.HandlerFunc)
+	Trace(pattern string, h http.HandlerFunc)
+
+	// NotFound defines a handler to respond whenever a route could
+	// not be found.
+	NotFound(h http.HandlerFunc)
+}
+
+// Routes interface adds two methods for router traversal, which is also
+// used by the `docgen` subpackage to generation documentation for Routers.
+type Routes interface {
+	// Routes returns the routing tree in an easily traversable structure.
+	Routes() []Route
+
+	// Middlewares returns the list of middlewares in use by the router.
+	Middlewares() Middlewares
+}
+```
+
+Each routing method accepts a URL `pattern` and chain of `handlers`. The URL pattern
+supports named params (ie. `/users/:userID`) and wildcards (ie. `/admin/*`).
+
+
+### Middleware handlers
+
+chi's middlewares are just stdlib net/http middleware handlers. There is nothing special
+about them, which means the router and all the tooling is designed to be compatible and
+friendly with any middleware in the community. This offers much better extensibility and reuse
+of packages and is at the heart of chi's purpose.
+
+Here is an example of a standard net/http middleware handler using the new request context
+available in Go 1.7+. This middleware sets a hypothetical user identifier on the request
+context and calls the next handler in the chain.
+
+```go
+// HTTP middleware setting a value on the request context
+func MyMiddleware(next http.Handler) http.Handler {
+  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    ctx := context.WithValue(r.Context(), "user", "123")
+    next.ServeHTTP(w, r.WithContext(ctx))
+  })
+}
+```
+
+
+### Request handlers
+
+chi uses standard net/http request handlers. This little snippet is an example of a http.Handler
+func that reads a user identifier from the request context - hypothetically, identifying
+the user sending an authenticated request, validated+set by a previous middleware handler.
+
+```go
+// HTTP handler accessing data from the request context.
+func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
+  user := r.Context().Value("user").(string)
+  w.Write([]byte(fmt.Sprintf("hi %s", user)))
+}
+```
+
+
+### URL parameters
+
+chi's router parses and stores URL parameters right onto the request context. Here is
+an example of how to access URL params in your net/http handlers. And of course, middlewares
+are able to access the same information.
+
+```go
+// HTTP handler accessing the url routing parameters.
+func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
+  userID := chi.URLParam(r, "userID") // from a route like /users/:userID
+
+  ctx := r.Context()
+  key := ctx.Value("key").(string)
+
+  w.Write([]byte(fmt.Sprintf("hi %v, %v", userID, key)))
+}
+```
+
+
+## Middlewares
+
+chi comes equipped with an optional `middleware` package, providing a suite of standard
+`net/http` middlewares. Please note, any middleware in the ecosystem that is also compatible
+with `net/http` can be used with chi's mux.
+
+----------------------------------------------------------------------------------------------------------
+| Middleware           | Description                                                                     |
+|:---------------------|:---------------------------------------------------------------------------------
+| RequestID            | Injects a request ID into the context of each request.                          |
+| RealIP               | Sets a http.Request's RemoteAddr to either X-Forwarded-For or X-Real-IP.        |
+| Logger               | Logs the start and end of each request with the elapsed processing time.        |
+| Recoverer            | Gracefully absorb panics and prints the stack trace.                            |
+| NoCache              | Sets response headers to prevent clients from caching.                          |
+| Timeout              | Signals to the request context when the timeout deadline is reached.            |
+| Throttle             | Puts a ceiling on the number of concurrent requests.                            |
+| Compress             | Gzip compression for clients that accept compressed responses.                  |
+| Profiler             | Easily attach net/http/pprof to your routers.                                   |
+| StripSlashes         | Strip slashes on routing paths.                                                 |
+| RedirectSlashes      | Redirect slashes on routing paths.                                              |
+| WithValue            | Short-hand middleware to set a key/value on the request context.                |
+| Heartbeat            | Monitoring endpoint to check the servers pulse.                                 |
+----------------------------------------------------------------------------------------------------------
+
+Other cool net/http middlewares:
+
+* [jwtauth](https://github.com/goware/jwtauth) - JWT authenticator
+* [cors](https://github.com/goware/cors) - CORS middleware
+* [httpcoala](https://github.com/goware/httpcoala) - Request coalescer
+
+please [submit a PR](./CONTRIBUTING.md) if you'd like to include a link to a chi middleware
+
+
+## context?
+
+`context` is a tiny pkg that provides simple interface to signal context across call stacks
+and goroutines. It was originally written by [Sameer Ajmani](https://github.com/Sajmani)
+and is available in stdlib since go1.7.
+
+Learn more at https://blog.golang.org/context
+
+and..
+* Docs: https://golang.org/pkg/context
+* Source: https://github.com/golang/go/tree/master/src/context
+
+
+## Benchmarks
+
+The benchmark suite: https://github.com/pkieltyka/go-http-routing-benchmark
+
+Comparison with other routers (as of Jan 7/17): https://gist.github.com/pkieltyka/d0814d5396c996cb3ff8076399583d1f
+
+```shell
+BenchmarkChi_Param        	 5000000	       398 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_Param5       	 3000000	       556 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_Param20      	 1000000	      1184 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_ParamWrite   	 3000000	       443 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GithubStatic 	 3000000	       427 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GithubParam  	 3000000	       565 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GithubAll    	   10000	    122143 ns/op	   61716 B/op	     406 allocs/op
+BenchmarkChi_GPlusStatic  	 5000000	       383 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GPlusParam   	 3000000	       431 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GPlus2Params 	 3000000	       500 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GPlusAll     	  200000	      6410 ns/op	    3952 B/op	      26 allocs/op
+BenchmarkChi_ParseStatic  	 5000000	       384 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_ParseParam   	 3000000	       415 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_Parse2Params 	 3000000	       450 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_ParseAll     	  100000	     12124 ns/op	    7904 B/op	      52 allocs/op
+BenchmarkChi_StaticAll    	   20000	     78501 ns/op	   47731 B/op	     314 allocs/op
+```
+
+NOTE: the allocs in the benchmark above are from the calls to http.Request's
+`WithContext(context.Context)` method that clones the http.Request, sets the `Context()`
+on the duplicated (alloc'd) request and returns it the new request object. This is just
+how setting context on a request in Go 1.7+ works.
+
+
+## Credits
+
+* Carl Jackson for https://github.com/zenazn/goji
+  * Parts of chi's thinking comes from goji, and chi's middleware package
+    sources from goji.
+* Armon Dadgar for https://github.com/armon/go-radix
+* Contributions: [@VojtechVitek](https://github.com/VojtechVitek)
+
+We'll be more than happy to see [your contributions](./CONTRIBUTING.md)!
+
+
+## Beyond REST
+
+chi is just a http router that lets you decompose request handling into many smaller layers.
+Many companies including Pressly.com (of course) use chi to write REST services for their public
+APIs. But, REST is just a convention for managing state via HTTP, and there's a lot of other pieces
+required to write a complete client-server system or network of microservices.
+
+Looking ahead beyond REST, I also recommend some newer works in the field coming from
+[gRPC](https://github.com/grpc/grpc-go), [NATS](https://nats.io), [go-kit](https://github.com/go-kit/kit)
+and even [graphql](https://github.com/graphql-go/graphql). They're all pretty cool with their
+own unique approaches and benefits. Specifically, I'd look at gRPC since it makes client-server
+communication feel like a single program on a single computer, no need to hand-write a client library
+and the request/response payloads are typed contracts. NATS is pretty amazing too as a super
+fast and lightweight pub-sub transport that can speak protobufs, with nice service discovery -
+an excellent combination with gRPC.
+
+
+## License
+
+Copyright (c) 2015-present [Peter Kieltyka](https://github.com/pkieltyka)
+
+Licensed under [MIT License](./LICENSE)
+
+[GoDoc]: https://godoc.org/github.com/pressly/chi
+[GoDoc Widget]: https://godoc.org/github.com/pressly/chi?status.svg
+[Travis]: https://travis-ci.org/pressly/chi
+[Travis Widget]: https://travis-ci.org/pressly/chi.svg?branch=master

vendor/github.com/pressly/chi/chain.go

@@ -0,0 +1,47 @@
+package chi
+
+import "net/http"
+
+// Chain returns a Middlewares type from a slice of middleware handlers.
+func Chain(middlewares ...func(http.Handler) http.Handler) Middlewares {
+	return Middlewares(middlewares)
+}
+
+// Handler builds and returns a http.Handler from the chain of middlewares,
+// with `h http.Handler` as the final handler.
+func (mws Middlewares) Handler(h http.Handler) http.Handler {
+	return &ChainHandler{mws, h, chain(mws, h)}
+}
+
+// HandlerFunc builds and returns a http.Handler from the chain of middlewares,
+// with `h http.Handler` as the final handler.
+func (mws Middlewares) HandlerFunc(h http.HandlerFunc) http.Handler {
+	return &ChainHandler{mws, h, chain(mws, h)}
+}
+
+type ChainHandler struct {
+	Middlewares Middlewares
+	Endpoint    http.Handler
+	chain       http.Handler
+}
+
+func (c *ChainHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	c.chain.ServeHTTP(w, r)
+}
+
+// chain builds a http.Handler composed of an inline middleware stack and endpoint
+// handler in the order they are passed.
+func chain(middlewares []func(http.Handler) http.Handler, endpoint http.Handler) http.Handler {
+	// Return ahead of time if there aren't any middlewares for the chain
+	if len(middlewares) == 0 {
+		return endpoint
+	}
+
+	// Wrap the end handler with the middleware chain
+	h := middlewares[len(middlewares)-1](endpoint)
+	for i := len(middlewares) - 2; i >= 0; i-- {
+		h = middlewares[i](h)
+	}
+
+	return h
+}

vendor/github.com/pressly/chi/chi.go

@@ -0,0 +1,98 @@
+//
+// Package chi is a small, idiomatic and composable router for building HTTP services.
+//
+// chi requires Go 1.7 or newer.
+//
+// Example:
+//  package main
+//
+//  import (
+//  	"net/http"
+//
+//  	"github.com/pressly/chi"
+//  	"github.com/pressly/chi/middleware"
+//  )
+//
+//  func main() {
+//  	r := chi.NewRouter()
+//  	r.Use(middleware.Logger)
+//  	r.Use(middleware.Recoverer)
+//
+//  	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+//  		w.Write([]byte("root."))
+//  	})
+//
+//  	http.ListenAndServe(":3333", r)
+//  }
+//
+// See github.com/pressly/chi/_examples/ for more in-depth examples.
+//
+package chi
+
+import "net/http"
+
+// NewRouter returns a new Mux object that implements the Router interface.
+func NewRouter() *Mux {
+	return NewMux()
+}
+
+// Router consisting of the core routing methods used by chi's Mux,
+// using only the standard net/http.
+type Router interface {
+	http.Handler
+	Routes
+
+	// Use appends one of more middlewares onto the Router stack.
+	Use(middlewares ...func(http.Handler) http.Handler)
+
+	// With adds inline middlewares for an endpoint handler.
+	With(middlewares ...func(http.Handler) http.Handler) Router
+
+	// Group adds a new inline-Router along the current routing
+	// path, with a fresh middleware stack for the inline-Router.
+	Group(fn func(r Router)) Router
+
+	// Route mounts a sub-Router along a `pattern`` string.
+	Route(pattern string, fn func(r Router)) Router
+
+	// Mount attaches another http.Handler along ./pattern/*
+	Mount(pattern string, h http.Handler)
+
+	// Handle and HandleFunc adds routes for `pattern` that matches
+	// all HTTP methods.
+	Handle(pattern string, h http.Handler)
+	HandleFunc(pattern string, h http.HandlerFunc)
+
+	// HTTP-method routing along `pattern`
+	Connect(pattern string, h http.HandlerFunc)
+	Delete(pattern string, h http.HandlerFunc)
+	Get(pattern string, h http.HandlerFunc)
+	Head(pattern string, h http.HandlerFunc)
+	Options(pattern string, h http.HandlerFunc)
+	Patch(pattern string, h http.HandlerFunc)
+	Post(pattern string, h http.HandlerFunc)
+	Put(pattern string, h http.HandlerFunc)
+	Trace(pattern string, h http.HandlerFunc)
+
+	// NotFound defines a handler to respond whenever a route could
+	// not be found.
+	NotFound(h http.HandlerFunc)
+
+	// MethodNotAllowed defines a handler to respond whenever a method is
+	// not allowed.
+	MethodNotAllowed(h http.HandlerFunc)
+}
+
+// Routes interface adds two methods for router traversal, which is also
+// used by the `docgen` subpackage to generation documentation for Routers.
+type Routes interface {
+	// Routes returns the routing tree in an easily traversable structure.
+	Routes() []Route
+
+	// Middlewares returns the list of middlewares in use by the router.
+	Middlewares() Middlewares
+}
+
+// Middlewares type is a slice of standard middleware handlers with methods
+// to compose middleware chains and http.Handler's.
+type Middlewares []func(http.Handler) http.Handler

vendor/github.com/pressly/chi/context.go

@@ -0,0 +1,138 @@
+package chi
+
+import (
+	"context"
+	"net"
+	"net/http"
+)
+
+var (
+	RouteCtxKey = &contextKey{"RouteContext"}
+)
+
+// Context is the default routing context set on the root node of a
+// request context to track URL parameters and an optional routing path.
+type Context struct {
+	// URL routing parameter key and values.
+	URLParams params
+
+	// Routing path override used by subrouters.
+	RoutePath string
+
+	// Routing pattern matching the path.
+	RoutePattern string
+
+	// Routing patterns throughout the lifecycle of the request,
+	// across all connected routers.
+	RoutePatterns []string
+}
+
+// NewRouteContext returns a new routing Context object.
+func NewRouteContext() *Context {
+	return &Context{}
+}
+
+// reset a routing context to its initial state.
+func (x *Context) reset() {
+	x.URLParams = x.URLParams[:0]
+	x.RoutePath = ""
+	x.RoutePattern = ""
+	x.RoutePatterns = x.RoutePatterns[:0]
+}
+
+// RouteContext returns chi's routing Context object from a
+// http.Request Context.
+func RouteContext(ctx context.Context) *Context {
+	return ctx.Value(RouteCtxKey).(*Context)
+}
+
+// URLParam returns the url parameter from a http.Request object.
+func URLParam(r *http.Request, key string) string {
+	if rctx := RouteContext(r.Context()); rctx != nil {
+		return rctx.URLParams.Get(key)
+	}
+	return ""
+}
+
+// URLParamFromCtx returns the url parameter from a http.Request Context.
+func URLParamFromCtx(ctx context.Context, key string) string {
+	if rctx := RouteContext(ctx); rctx != nil {
+		return rctx.URLParams.Get(key)
+	}
+	return ""
+}
+
+type param struct {
+	Key, Value string
+}
+
+type params []param
+
+func (ps *params) Add(key string, value string) {
+	*ps = append(*ps, param{key, value})
+}
+
+func (ps params) Get(key string) string {
+	for _, p := range ps {
+		if p.Key == key {
+			return p.Value
+		}
+	}
+	return ""
+}
+
+func (ps *params) Set(key string, value string) {
+	idx := -1
+	for i, p := range *ps {
+		if p.Key == key {
+			idx = i
+			break
+		}
+	}
+	if idx < 0 {
+		(*ps).Add(key, value)
+	} else {
+		(*ps)[idx] = param{key, value}
+	}
+}
+
+func (ps *params) Del(key string) string {
+	for i, p := range *ps {
+		if p.Key == key {
+			*ps = append((*ps)[:i], (*ps)[i+1:]...)
+			return p.Value
+		}
+	}
+	return ""
+}
+
+// ServerBaseContext wraps an http.Handler to set the request context to the
+// `baseCtx`.
+func ServerBaseContext(h http.Handler, baseCtx context.Context) http.Handler {
+	fn := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
+		baseCtx := baseCtx
+
+		// Copy over default net/http server context keys
+		if v, ok := ctx.Value(http.ServerContextKey).(*http.Server); ok {
+			baseCtx = context.WithValue(baseCtx, http.ServerContextKey, v)
+		}
+		if v, ok := ctx.Value(http.LocalAddrContextKey).(net.Addr); ok {
+			baseCtx = context.WithValue(baseCtx, http.LocalAddrContextKey, v)
+		}
+
+		h.ServeHTTP(w, r.WithContext(baseCtx))
+	})
+	return fn
+}
+
+// contextKey is a value for use with context.WithValue. It's used as
+// a pointer so it fits in an interface{} without allocation. This technique
+// for defining context keys was copied from Go 1.7's new use of context in net/http.
+type contextKey struct {
+	name string
+}
+
+func (k *contextKey) String() string {
+	return "chi context value " + k.name
+}

vendor/github.com/pressly/chi/middleware/closenotify17.go

@@ -0,0 +1,42 @@
+// +build go1.7,!go1.8
+
+package middleware
+
+import (
+	"context"
+	"net/http"
+)
+
+// CloseNotify is a middleware that cancels ctx when the underlying
+// connection has gone away. It can be used to cancel long operations
+// on the server when the client disconnects before the response is ready.
+//
+// Note: this behaviour is standard in Go 1.8+, so the middleware does nothing
+// on 1.8+ and exists just for backwards compatibility.
+func CloseNotify(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		cn, ok := w.(http.CloseNotifier)
+		if !ok {
+			panic("chi/middleware: CloseNotify expects http.ResponseWriter to implement http.CloseNotifier interface")
+		}
+		closeNotifyCh := cn.CloseNotify()
+
+		ctx, cancel := context.WithCancel(r.Context())
+		defer cancel()
+
+		go func() {
+			select {
+			case <-ctx.Done():
+				return
+			case <-closeNotifyCh:
+				cancel()
+				return
+			}
+		}()
+
+		r = r.WithContext(ctx)
+		next.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}

vendor/github.com/pressly/chi/middleware/closenotify18.go

@@ -0,0 +1,17 @@
+// +build go1.8
+
+package middleware
+
+import (
+	"net/http"
+)
+
+// CloseNotify is a middleware that cancels ctx when the underlying
+// connection has gone away. It can be used to cancel long operations
+// on the server when the client disconnects before the response is ready.
+//
+// Note: this behaviour is standard in Go 1.8+, so the middleware does nothing
+// on 1.8+ and exists just for backwards compatibility.
+func CloseNotify(next http.Handler) http.Handler {
+	return next
+}

vendor/github.com/pressly/chi/middleware/compress.go

@@ -0,0 +1,212 @@
+package middleware
+
+import (
+	"bufio"
+	"compress/flate"
+	"compress/gzip"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+)
+
+type encoding int
+
+const (
+	encodingNone encoding = iota
+	encodingGzip
+	encodingDeflate
+)
+
+var defaultContentTypes = map[string]struct{}{
+	"text/html":                struct{}{},
+	"text/css":                 struct{}{},
+	"text/plain":               struct{}{},
+	"text/javascript":          struct{}{},
+	"application/javascript":   struct{}{},
+	"application/x-javascript": struct{}{},
+	"application/json":         struct{}{},
+	"application/atom+xml":     struct{}{},
+	"application/rss+xml ":     struct{}{},
+}
+
+// DefaultCompress is a middleware that compresses response
+// body of predefined content types to a data format based
+// on Accept-Encoding request header. It uses a default
+// compression level.
+func DefaultCompress(next http.Handler) http.Handler {
+	return Compress(flate.DefaultCompression)(next)
+}
+
+// Compress is a middleware that compresses response
+// body of a given content types to a data format based
+// on Accept-Encoding request header. It uses a given
+// compression level.
+func Compress(level int, types ...string) func(next http.Handler) http.Handler {
+	contentTypes := defaultContentTypes
+	if len(types) > 0 {
+		contentTypes = make(map[string]struct{}, len(types))
+		for _, t := range types {
+			contentTypes[t] = struct{}{}
+		}
+	}
+
+	return func(next http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			mcw := &maybeCompressResponseWriter{
+				ResponseWriter: w,
+				w:              w,
+				contentTypes:   contentTypes,
+				encoding:       selectEncoding(r.Header),
+				level:          level,
+			}
+			defer mcw.Close()
+
+			next.ServeHTTP(mcw, r)
+		}
+
+		return http.HandlerFunc(fn)
+	}
+}
+
+func selectEncoding(h http.Header) encoding {
+	enc := h.Get("Accept-Encoding")
+
+	switch {
+	// TODO:
+	// case "br":    // Brotli, experimental. Firefox 2016, to-be-in Chromium.
+	// case "lzma":  // Opera.
+	// case "sdch":  // Chrome, Android. Gzip output + dictionary header.
+
+	case strings.Contains(enc, "gzip"):
+		// TODO: Exception for old MSIE browsers that can't handle non-HTML?
+		// https://zoompf.com/blog/2012/02/lose-the-wait-http-compression
+		return encodingGzip
+
+	case strings.Contains(enc, "deflate"):
+		// HTTP 1.1 "deflate" (RFC 2616) stands for DEFLATE data (RFC 1951)
+		// wrapped with zlib (RFC 1950). The zlib wrapper uses Adler-32
+		// checksum compared to CRC-32 used in "gzip" and thus is faster.
+		//
+		// But.. some old browsers (MSIE, Safari 5.1) incorrectly expect
+		// raw DEFLATE data only, without the mentioned zlib wrapper.
+		// Because of this major confusion, most modern browsers try it
+		// both ways, first looking for zlib headers.
+		// Quote by Mark Adler: http://stackoverflow.com/a/9186091/385548
+		//
+		// The list of browsers having problems is quite big, see:
+		// http://zoompf.com/blog/2012/02/lose-the-wait-http-compression
+		// https://web.archive.org/web/20120321182910/http://www.vervestudios.co/projects/compression-tests/results
+		//
+		// That's why we prefer gzip over deflate. It's just more reliable
+		// and not significantly slower than gzip.
+		return encodingDeflate
+
+		// NOTE: Not implemented, intentionally:
+		// case "compress": // LZW. Deprecated.
+		// case "bzip2":    // Too slow on-the-fly.
+		// case "zopfli":   // Too slow on-the-fly.
+		// case "xz":       // Too slow on-the-fly.
+	}
+
+	return encodingNone
+}
+
+type maybeCompressResponseWriter struct {
+	http.ResponseWriter
+	w            io.Writer
+	encoding     encoding
+	contentTypes map[string]struct{}
+	level        int
+	wroteHeader  bool
+}
+
+func (w *maybeCompressResponseWriter) WriteHeader(code int) {
+	if w.wroteHeader {
+		return
+	}
+	w.wroteHeader = true
+	defer w.ResponseWriter.WriteHeader(code)
+
+	// Already compressed data?
+	if w.ResponseWriter.Header().Get("Content-Encoding") != "" {
+		return
+	}
+	// The content-length after compression is unknown
+	w.ResponseWriter.Header().Del("Content-Length")
+
+	// Parse the first part of the Content-Type response header.
+	contentType := ""
+	parts := strings.Split(w.ResponseWriter.Header().Get("Content-Type"), ";")
+	if len(parts) > 0 {
+		contentType = parts[0]
+	}
+
+	// Is the content type compressable?
+	if _, ok := w.contentTypes[contentType]; !ok {
+		return
+	}
+
+	// Select the compress writer.
+	switch w.encoding {
+	case encodingGzip:
+		gw, err := gzip.NewWriterLevel(w.ResponseWriter, w.level)
+		if err != nil {
+			w.w = w.ResponseWriter
+			return
+		}
+		w.w = gw
+		w.ResponseWriter.Header().Set("Content-Encoding", "gzip")
+
+	case encodingDeflate:
+		dw, err := flate.NewWriter(w.ResponseWriter, w.level)
+		if err != nil {
+			w.w = w.ResponseWriter
+			return
+		}
+		w.w = dw
+		w.ResponseWriter.Header().Set("Content-Encoding", "deflate")
+	}
+}
+
+func (w *maybeCompressResponseWriter) Write(p []byte) (int, error) {
+	if !w.wroteHeader {
+		w.WriteHeader(http.StatusOK)
+	}
+
+	return w.w.Write(p)
+}
+
+func (w *maybeCompressResponseWriter) Flush() {
+	if f, ok := w.w.(http.Flusher); ok {
+		f.Flush()
+	}
+}
+
+func (w *maybeCompressResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	if hj, ok := w.w.(http.Hijacker); ok {
+		return hj.Hijack()
+	}
+	return nil, nil, errors.New("chi/middleware: http.Hijacker is unavailable on the writer")
+}
+
+func (w *maybeCompressResponseWriter) CloseNotify() <-chan bool {
+	if cn, ok := w.w.(http.CloseNotifier); ok {
+		return cn.CloseNotify()
+	}
+
+	// If the underlying writer does not implement http.CloseNotifier, return
+	// a channel that never receives a value. The semantics here is that the
+	// client never disconnnects before the request is processed by the
+	// http.Handler, which is close enough to the default behavior (when
+	// CloseNotify() is not even called).
+	return make(chan bool, 1)
+}
+
+func (w *maybeCompressResponseWriter) Close() error {
+	if c, ok := w.w.(io.WriteCloser); ok {
+		return c.Close()
+	}
+	return errors.New("chi/middleware: io.WriteCloser is unavailable on the writer")
+}

vendor/github.com/pressly/chi/middleware/compress18.go

@@ -0,0 +1,15 @@
+// +build go1.8
+
+package middleware
+
+import (
+	"errors"
+	"net/http"
+)
+
+func (w *maybeCompressResponseWriter) Push(target string, opts *http.PushOptions) error {
+	if ps, ok := w.w.(http.Pusher); ok {
+		return ps.Push(target, opts)
+	}
+	return errors.New("chi/middleware: http.Pusher is unavailable on the writer")
+}

vendor/github.com/pressly/chi/middleware/heartbeat.go

@@ -0,0 +1,26 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+)
+
+// Heartbeat endpoint middleware useful to setting up a path like
+// `/ping` that load balancers or uptime testing external services
+// can make a request before hitting any routes. It's also convenient
+// to place this above ACL middlewares as well.
+func Heartbeat(endpoint string) func(http.Handler) http.Handler {
+	f := func(h http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			if r.Method == "GET" && strings.EqualFold(r.URL.Path, endpoint) {
+				w.Header().Set("Content-Type", "text/plain")
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte("."))
+				return
+			}
+			h.ServeHTTP(w, r)
+		}
+		return http.HandlerFunc(fn)
+	}
+	return f
+}

vendor/github.com/pressly/chi/middleware/logger.go

@@ -0,0 +1,137 @@
+package middleware
+
+import (
+	"bytes"
+	"context"
+	"log"
+	"net/http"
+	"os"
+	"time"
+)
+
+var (
+	LogEntryCtxKey = &contextKey{"LogEntry"}
+
+	DefaultLogger = RequestLogger(&DefaultLogFormatter{Logger: log.New(os.Stdout, "", log.LstdFlags)})
+)
+
+// Logger is a middleware that logs the start and end of each request, along
+// with some useful data about what was requested, what the response status was,
+// and how long it took to return. When standard output is a TTY, Logger will
+// print in color, otherwise it will print in black and white. Logger prints a
+// request ID if one is provided.
+//
+// Alternatively, look at https://github.com/pressly/lg and the `lg.RequestLogger`
+// middleware pkg.
+func Logger(next http.Handler) http.Handler {
+	return DefaultLogger(next)
+}
+
+func RequestLogger(f LogFormatter) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			entry := f.NewLogEntry(r)
+			ww := NewWrapResponseWriter(w, r.ProtoMajor)
+
+			t1 := time.Now()
+			defer func() {
+				t2 := time.Now()
+				entry.Write(ww.Status(), ww.BytesWritten(), t2.Sub(t1))
+			}()
+
+			next.ServeHTTP(ww, WithLogEntry(r, entry))
+		}
+		return http.HandlerFunc(fn)
+	}
+}
+
+type LogFormatter interface {
+	NewLogEntry(r *http.Request) LogEntry
+}
+
+type LogEntry interface {
+	Write(status, bytes int, elapsed time.Duration)
+	Panic(v interface{}, stack []byte)
+}
+
+func GetLogEntry(r *http.Request) LogEntry {
+	entry, _ := r.Context().Value(LogEntryCtxKey).(LogEntry)
+	return entry
+}
+
+func WithLogEntry(r *http.Request, entry LogEntry) *http.Request {
+	r = r.WithContext(context.WithValue(r.Context(), LogEntryCtxKey, entry))
+	return r
+}
+
+type DefaultLogFormatter struct {
+	Logger *log.Logger
+}
+
+func (l *DefaultLogFormatter) NewLogEntry(r *http.Request) LogEntry {
+	entry := &defaultLogEntry{
+		DefaultLogFormatter: l,
+		request:             r,
+		buf:                 &bytes.Buffer{},
+	}
+
+	reqID := GetReqID(r.Context())
+	if reqID != "" {
+		cW(entry.buf, nYellow, "[%s] ", reqID)
+	}
+	cW(entry.buf, nCyan, "\"")
+	cW(entry.buf, bMagenta, "%s ", r.Method)
+
+	scheme := "http"
+	if r.TLS != nil {
+		scheme = "https"
+	}
+	cW(entry.buf, nCyan, "%s://%s%s %s\" ", scheme, r.Host, r.RequestURI, r.Proto)
+
+	entry.buf.WriteString("from ")
+	entry.buf.WriteString(r.RemoteAddr)
+	entry.buf.WriteString(" - ")
+
+	return entry
+}
+
+type defaultLogEntry struct {
+	*DefaultLogFormatter
+	request *http.Request
+	buf     *bytes.Buffer
+}
+
+func (l *defaultLogEntry) Write(status, bytes int, elapsed time.Duration) {
+	switch {
+	case status < 200:
+		cW(l.buf, bBlue, "%03d", status)
+	case status < 300:
+		cW(l.buf, bGreen, "%03d", status)
+	case status < 400:
+		cW(l.buf, bCyan, "%03d", status)
+	case status < 500:
+		cW(l.buf, bYellow, "%03d", status)
+	default:
+		cW(l.buf, bRed, "%03d", status)
+	}
+
+	cW(l.buf, bBlue, " %dB", bytes)
+
+	l.buf.WriteString(" in ")
+	if elapsed < 500*time.Millisecond {
+		cW(l.buf, nGreen, "%s", elapsed)
+	} else if elapsed < 5*time.Second {
+		cW(l.buf, nYellow, "%s", elapsed)
+	} else {
+		cW(l.buf, nRed, "%s", elapsed)
+	}
+
+	l.Logger.Print(l.buf.String())
+}
+
+func (l *defaultLogEntry) Panic(v interface{}, stack []byte) {
+	panicEntry := l.NewLogEntry(l.request).(*defaultLogEntry)
+	cW(panicEntry.buf, bRed, "panic: %+v", v)
+	l.Logger.Print(panicEntry.buf.String())
+	l.Logger.Print(string(stack))
+}

vendor/github.com/pressly/chi/middleware/middleware.go

@@ -0,0 +1,12 @@
+package middleware
+
+// contextKey is a value for use with context.WithValue. It's used as
+// a pointer so it fits in an interface{} without allocation. This technique
+// for defining context keys was copied from Go 1.7's new use of context in net/http.
+type contextKey struct {
+	name string
+}
+
+func (k *contextKey) String() string {
+	return "chi/middleware context value " + k.name
+}

vendor/github.com/pressly/chi/middleware/nocache.go

@@ -0,0 +1,58 @@
+package middleware
+
+// Ported from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"net/http"
+	"time"
+)
+
+// Unix epoch time
+var epoch = time.Unix(0, 0).Format(time.RFC1123)
+
+// Taken from https://github.com/mytrile/nocache
+var noCacheHeaders = map[string]string{
+	"Expires":         epoch,
+	"Cache-Control":   "no-cache, private, max-age=0",
+	"Pragma":          "no-cache",
+	"X-Accel-Expires": "0",
+}
+
+var etagHeaders = []string{
+	"ETag",
+	"If-Modified-Since",
+	"If-Match",
+	"If-None-Match",
+	"If-Range",
+	"If-Unmodified-Since",
+}
+
+// NoCache is a simple piece of middleware that sets a number of HTTP headers to prevent
+// a router (or subrouter) from being cached by an upstream proxy and/or client.
+//
+// As per http://wiki.nginx.org/HttpProxyModule - NoCache sets:
+//      Expires: Thu, 01 Jan 1970 00:00:00 UTC
+//      Cache-Control: no-cache, private, max-age=0
+//      X-Accel-Expires: 0
+//      Pragma: no-cache (for HTTP/1.0 proxies/clients)
+func NoCache(h http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+
+		// Delete any ETag headers that may have been set
+		for _, v := range etagHeaders {
+			if r.Header.Get(v) != "" {
+				r.Header.Del(v)
+			}
+		}
+
+		// Set our NoCache headers
+		for k, v := range noCacheHeaders {
+			w.Header().Set(k, v)
+		}
+
+		h.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}

vendor/github.com/pressly/chi/middleware/profiler.go

@@ -0,0 +1,58 @@
+package middleware
+
+import (
+	"expvar"
+	"fmt"
+	"net/http"
+	"net/http/pprof"
+
+	"github.com/pressly/chi"
+)
+
+// Profiler is a convenient subrouter used for mounting net/http/pprof. ie.
+//
+//  func MyService() http.Handler {
+//    r := chi.NewRouter()
+//    // ..middlewares
+//    r.Mount("/debug", middleware.Profiler())
+//    // ..routes
+//    return r
+//  }
+func Profiler() http.Handler {
+	r := chi.NewRouter()
+	r.Use(NoCache)
+
+	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+		http.Redirect(w, r, r.RequestURI+"/pprof/", 301)
+	})
+	r.HandleFunc("/pprof", func(w http.ResponseWriter, r *http.Request) {
+		http.Redirect(w, r, r.RequestURI+"/", 301)
+	})
+
+	r.HandleFunc("/pprof/", pprof.Index)
+	r.HandleFunc("/pprof/cmdline", pprof.Cmdline)
+	r.HandleFunc("/pprof/profile", pprof.Profile)
+	r.HandleFunc("/pprof/symbol", pprof.Symbol)
+	r.Handle("/pprof/block", pprof.Handler("block"))
+	r.Handle("/pprof/heap", pprof.Handler("heap"))
+	r.Handle("/pprof/goroutine", pprof.Handler("goroutine"))
+	r.Handle("/pprof/threadcreate", pprof.Handler("threadcreate"))
+	r.HandleFunc("/vars", expVars)
+
+	return r
+}
+
+// Replicated from expvar.go as not public.
+func expVars(w http.ResponseWriter, r *http.Request) {
+	first := true
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	fmt.Fprintf(w, "{\n")
+	expvar.Do(func(kv expvar.KeyValue) {
+		if !first {
+			fmt.Fprintf(w, ",\n")
+		}
+		first = false
+		fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)
+	})
+	fmt.Fprintf(w, "\n}\n")
+}

vendor/github.com/pressly/chi/middleware/realip.go

@@ -0,0 +1,54 @@
+package middleware
+
+// Ported from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"net/http"
+	"strings"
+)
+
+var xForwardedFor = http.CanonicalHeaderKey("X-Forwarded-For")
+var xRealIP = http.CanonicalHeaderKey("X-Real-IP")
+
+// RealIP is a middleware that sets a http.Request's RemoteAddr to the results
+// of parsing either the X-Forwarded-For header or the X-Real-IP header (in that
+// order).
+//
+// This middleware should be inserted fairly early in the middleware stack to
+// ensure that subsequent layers (e.g., request loggers) which examine the
+// RemoteAddr will see the intended value.
+//
+// You should only use this middleware if you can trust the headers passed to
+// you (in particular, the two headers this middleware uses), for example
+// because you have placed a reverse proxy like HAProxy or nginx in front of
+// Goji. If your reverse proxies are configured to pass along arbitrary header
+// values from the client, or if you use this middleware without a reverse
+// proxy, malicious clients will be able to make you very sad (or, depending on
+// how you're using RemoteAddr, vulnerable to an attack of some sort).
+func RealIP(h http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		if rip := realIP(r); rip != "" {
+			r.RemoteAddr = rip
+		}
+		h.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}
+
+func realIP(r *http.Request) string {
+	var ip string
+
+	if xff := r.Header.Get(xForwardedFor); xff != "" {
+		i := strings.Index(xff, ", ")
+		if i == -1 {
+			i = len(xff)
+		}
+		ip = xff[:i]
+	} else if xrip := r.Header.Get(xRealIP); xrip != "" {
+		ip = xrip
+	}
+
+	return ip
+}

vendor/github.com/pressly/chi/middleware/recoverer.go

@@ -0,0 +1,36 @@
+package middleware
+
+// The original work was derived from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"net/http"
+	"runtime/debug"
+)
+
+// Recoverer is a middleware that recovers from panics, logs the panic (and a
+// backtrace), and returns a HTTP 500 (Internal Server Error) status if
+// possible. Recoverer prints a request ID if one is provided.
+//
+// Alternatively, look at https://github.com/pressly/lg middleware pkgs.
+func Recoverer(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			if rvr := recover(); rvr != nil {
+
+				logEntry := GetLogEntry(r)
+				if logEntry != nil {
+					logEntry.Panic(rvr, debug.Stack())
+				} else {
+					debug.PrintStack()
+				}
+
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			}
+		}()
+
+		next.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}

vendor/github.com/pressly/chi/middleware/request_id.go

@@ -0,0 +1,88 @@
+package middleware
+
+// Ported from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+	"sync/atomic"
+)
+
+// Key to use when setting the request ID.
+type ctxKeyRequestID int
+
+// RequestIDKey is the key that holds th unique request ID in a request context.
+const RequestIDKey ctxKeyRequestID = 0
+
+var prefix string
+var reqid uint64
+
+// A quick note on the statistics here: we're trying to calculate the chance that
+// two randomly generated base62 prefixes will collide. We use the formula from
+// http://en.wikipedia.org/wiki/Birthday_problem
+//
+// P[m, n] \approx 1 - e^{-m^2/2n}
+//
+// We ballpark an upper bound for $m$ by imagining (for whatever reason) a server
+// that restarts every second over 10 years, for $m = 86400 * 365 * 10 = 315360000$
+//
+// For a $k$ character base-62 identifier, we have $n(k) = 62^k$
+//
+// Plugging this in, we find $P[m, n(10)] \approx 5.75%$, which is good enough for
+// our purposes, and is surely more than anyone would ever need in practice -- a
+// process that is rebooted a handful of times a day for a hundred years has less
+// than a millionth of a percent chance of generating two colliding IDs.
+
+func init() {
+	hostname, err := os.Hostname()
+	if hostname == "" || err != nil {
+		hostname = "localhost"
+	}
+	var buf [12]byte
+	var b64 string
+	for len(b64) < 10 {
+		rand.Read(buf[:])
+		b64 = base64.StdEncoding.EncodeToString(buf[:])
+		b64 = strings.NewReplacer("+", "", "/", "").Replace(b64)
+	}
+
+	prefix = fmt.Sprintf("%s/%s", hostname, b64[0:10])
+}
+
+// RequestID is a middleware that injects a request ID into the context of each
+// request. A request ID is a string of the form "host.example.com/random-0001",
+// where "random" is a base62 random string that uniquely identifies this go
+// process, and where the last number is an atomically incremented request
+// counter.
+func RequestID(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		myid := atomic.AddUint64(&reqid, 1)
+		ctx := r.Context()
+		ctx = context.WithValue(ctx, RequestIDKey, fmt.Sprintf("%s-%06d", prefix, myid))
+		next.ServeHTTP(w, r.WithContext(ctx))
+	}
+	return http.HandlerFunc(fn)
+}
+
+// GetReqID returns a request ID from the given context if one is present.
+// Returns the empty string if a request ID cannot be found.
+func GetReqID(ctx context.Context) string {
+	if ctx == nil {
+		return ""
+	}
+	if reqID, ok := ctx.Value(RequestIDKey).(string); ok {
+		return reqID
+	}
+	return ""
+}
+
+// NextRequestID generates the next request ID in the sequence.
+func NextRequestID() uint64 {
+	return atomic.AddUint64(&reqid, 1)
+}

vendor/github.com/pressly/chi/middleware/strip.go

@@ -0,0 +1,48 @@
+package middleware
+
+import (
+	"net/http"
+
+	"github.com/pressly/chi"
+)
+
+// StripSlashes is a middleware that will match request paths with a trailing
+// slash, strip it from the path and continue routing through the mux, if a route
+// matches, then it will serve the handler.
+func StripSlashes(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		var path string
+		rctx := chi.RouteContext(r.Context())
+		if rctx.RoutePath != "" {
+			path = rctx.RoutePath
+		} else {
+			path = r.URL.Path
+		}
+		if len(path) > 1 && path[len(path)-1] == '/' {
+			rctx.RoutePath = path[:len(path)-1]
+		}
+		next.ServeHTTP(w, r)
+	}
+	return http.HandlerFunc(fn)
+}
+
+// RedirectSlashes is a middleware that will match request paths with a trailing
+// slash and redirect to the same path, less the trailing slash.
+func RedirectSlashes(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		var path string
+		rctx := chi.RouteContext(r.Context())
+		if rctx.RoutePath != "" {
+			path = rctx.RoutePath
+		} else {
+			path = r.URL.Path
+		}
+		if len(path) > 1 && path[len(path)-1] == '/' {
+			path = path[:len(path)-1]
+			http.Redirect(w, r, path, 301)
+			return
+		}
+		next.ServeHTTP(w, r)
+	}
+	return http.HandlerFunc(fn)
+}

vendor/github.com/pressly/chi/middleware/terminal.go

@@ -0,0 +1,63 @@
+package middleware
+
+// Ported from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+var (
+	// Normal colors
+	nBlack   = []byte{'\033', '[', '3', '0', 'm'}
+	nRed     = []byte{'\033', '[', '3', '1', 'm'}
+	nGreen   = []byte{'\033', '[', '3', '2', 'm'}
+	nYellow  = []byte{'\033', '[', '3', '3', 'm'}
+	nBlue    = []byte{'\033', '[', '3', '4', 'm'}
+	nMagenta = []byte{'\033', '[', '3', '5', 'm'}
+	nCyan    = []byte{'\033', '[', '3', '6', 'm'}
+	nWhite   = []byte{'\033', '[', '3', '7', 'm'}
+	// Bright colors
+	bBlack   = []byte{'\033', '[', '3', '0', ';', '1', 'm'}
+	bRed     = []byte{'\033', '[', '3', '1', ';', '1', 'm'}
+	bGreen   = []byte{'\033', '[', '3', '2', ';', '1', 'm'}
+	bYellow  = []byte{'\033', '[', '3', '3', ';', '1', 'm'}
+	bBlue    = []byte{'\033', '[', '3', '4', ';', '1', 'm'}
+	bMagenta = []byte{'\033', '[', '3', '5', ';', '1', 'm'}
+	bCyan    = []byte{'\033', '[', '3', '6', ';', '1', 'm'}
+	bWhite   = []byte{'\033', '[', '3', '7', ';', '1', 'm'}
+
+	reset = []byte{'\033', '[', '0', 'm'}
+)
+
+var isTTY bool
+
+func init() {
+	// This is sort of cheating: if stdout is a character device, we assume
+	// that means it's a TTY. Unfortunately, there are many non-TTY
+	// character devices, but fortunately stdout is rarely set to any of
+	// them.
+	//
+	// We could solve this properly by pulling in a dependency on
+	// code.google.com/p/go.crypto/ssh/terminal, for instance, but as a
+	// heuristic for whether to print in color or in black-and-white, I'd
+	// really rather not.
+	fi, err := os.Stdout.Stat()
+	if err == nil {
+		m := os.ModeDevice | os.ModeCharDevice
+		isTTY = fi.Mode()&m == m
+	}
+}
+
+// colorWrite
+func cW(w io.Writer, color []byte, s string, args ...interface{}) {
+	if isTTY {
+		w.Write(color)
+	}
+	fmt.Fprintf(w, s, args...)
+	if isTTY {
+		w.Write(reset)
+	}
+}

vendor/github.com/pressly/chi/middleware/throttler.go

@@ -0,0 +1,101 @@
+package middleware
+
+import (
+	"net/http"
+	"time"
+)
+
+const (
+	errCapacityExceeded = "Server capacity exceeded."
+	errTimedOut         = "Timed out while waiting for a pending request to complete."
+	errContextCanceled  = "Context was canceled."
+)
+
+var (
+	defaultBacklogTimeout = time.Second * 60
+)
+
+// Throttle is a middleware that limits number of currently processed requests
+// at a time.
+func Throttle(limit int) func(http.Handler) http.Handler {
+	return ThrottleBacklog(limit, 0, defaultBacklogTimeout)
+}
+
+// ThrottleBacklog is a middleware that limits number of currently processed
+// requests at a time and provides a backlog for holding a finite number of
+// pending requests.
+func ThrottleBacklog(limit int, backlogLimit int, backlogTimeout time.Duration) func(http.Handler) http.Handler {
+	if limit < 1 {
+		panic("chi/middleware: Throttle expects limit > 0")
+	}
+
+	if backlogLimit < 0 {
+		panic("chi/middleware: Throttle expects backlogLimit to be positive")
+	}
+
+	t := throttler{
+		tokens:         make(chan token, limit),
+		backlogTokens:  make(chan token, limit+backlogLimit),
+		backlogTimeout: backlogTimeout,
+	}
+
+	// Filling tokens.
+	for i := 0; i < limit+backlogLimit; i++ {
+		if i < limit {
+			t.tokens <- token{}
+		}
+		t.backlogTokens <- token{}
+	}
+
+	fn := func(h http.Handler) http.Handler {
+		t.h = h
+		return &t
+	}
+
+	return fn
+}
+
+// token represents a request that is being processed.
+type token struct{}
+
+// throttler limits number of currently processed requests at a time.
+type throttler struct {
+	h              http.Handler
+	tokens         chan token
+	backlogTokens  chan token
+	backlogTimeout time.Duration
+}
+
+// ServeHTTP is the primary throttler request handler
+func (t *throttler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	select {
+	case <-ctx.Done():
+		http.Error(w, errContextCanceled, http.StatusServiceUnavailable)
+		return
+	case btok := <-t.backlogTokens:
+		timer := time.NewTimer(t.backlogTimeout)
+
+		defer func() {
+			t.backlogTokens <- btok
+		}()
+
+		select {
+		case <-timer.C:
+			http.Error(w, errTimedOut, http.StatusServiceUnavailable)
+			return
+		case <-ctx.Done():
+			http.Error(w, errContextCanceled, http.StatusServiceUnavailable)
+			return
+		case tok := <-t.tokens:
+			defer func() {
+				t.tokens <- tok
+			}()
+			t.h.ServeHTTP(w, r)
+		}
+		return
+	default:
+		http.Error(w, errCapacityExceeded, http.StatusServiceUnavailable)
+		return
+	}
+}

vendor/github.com/pressly/chi/middleware/timeout.go

@@ -0,0 +1,48 @@
+package middleware
+
+import (
+	"context"
+	"net/http"
+	"time"
+)
+
+// Timeout is a middleware that cancels ctx after a given timeout and return
+// a 504 Gateway Timeout error to the client.
+//
+// It's required that you select the ctx.Done() channel to check for the signal
+// if the context has reached its deadline and return, otherwise the timeout
+// signal will be just ignored.
+//
+// ie. a route/handler may look like:
+//
+//  r.Get("/long", func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
+// 	 processTime := time.Duration(rand.Intn(4)+1) * time.Second
+//
+// 	 select {
+// 	 case <-ctx.Done():
+// 	 	return
+//
+// 	 case <-time.After(processTime):
+// 	 	 // The above channel simulates some hard work.
+// 	 }
+//
+// 	 w.Write([]byte("done"))
+//  })
+//
+func Timeout(timeout time.Duration) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			ctx, cancel := context.WithTimeout(r.Context(), timeout)
+			defer func() {
+				cancel()
+				if ctx.Err() == context.DeadlineExceeded {
+					w.WriteHeader(http.StatusGatewayTimeout)
+				}
+			}()
+
+			r = r.WithContext(ctx)
+			next.ServeHTTP(w, r)
+		}
+		return http.HandlerFunc(fn)
+	}
+}

vendor/github.com/pressly/chi/middleware/value.go

@@ -0,0 +1,17 @@
+package middleware
+
+import (
+	"context"
+	"net/http"
+)
+
+// WithValue is a middleware that sets a given key/value in a context chain.
+func WithValue(key interface{}, val interface{}) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			r = r.WithContext(context.WithValue(r.Context(), key, val))
+			next.ServeHTTP(w, r)
+		}
+		return http.HandlerFunc(fn)
+	}
+}

vendor/github.com/pressly/chi/middleware/wrap_writer.go

@@ -0,0 +1,144 @@
+package middleware
+
+// The original work was derived from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+)
+
+// WrapResponseWriter is a proxy around an http.ResponseWriter that allows you to hook
+// into various parts of the response process.
+type WrapResponseWriter interface {
+	http.ResponseWriter
+	// Status returns the HTTP status of the request, or 0 if one has not
+	// yet been sent.
+	Status() int
+	// BytesWritten returns the total number of bytes sent to the client.
+	BytesWritten() int
+	// Tee causes the response body to be written to the given io.Writer in
+	// addition to proxying the writes through. Only one io.Writer can be
+	// tee'd to at once: setting a second one will overwrite the first.
+	// Writes will be sent to the proxy before being written to this
+	// io.Writer. It is illegal for the tee'd writer to be modified
+	// concurrently with writes.
+	Tee(io.Writer)
+	// Unwrap returns the original proxied target.
+	Unwrap() http.ResponseWriter
+}
+
+// basicWriter wraps a http.ResponseWriter that implements the minimal
+// http.ResponseWriter interface.
+type basicWriter struct {
+	http.ResponseWriter
+	wroteHeader bool
+	code        int
+	bytes       int
+	tee         io.Writer
+}
+
+func (b *basicWriter) WriteHeader(code int) {
+	if !b.wroteHeader {
+		b.code = code
+		b.wroteHeader = true
+		b.ResponseWriter.WriteHeader(code)
+	}
+}
+func (b *basicWriter) Write(buf []byte) (int, error) {
+	b.WriteHeader(http.StatusOK)
+	n, err := b.ResponseWriter.Write(buf)
+	if b.tee != nil {
+		_, err2 := b.tee.Write(buf[:n])
+		// Prefer errors generated by the proxied writer.
+		if err == nil {
+			err = err2
+		}
+	}
+	b.bytes += n
+	return n, err
+}
+func (b *basicWriter) maybeWriteHeader() {
+	if !b.wroteHeader {
+		b.WriteHeader(http.StatusOK)
+	}
+}
+func (b *basicWriter) Status() int {
+	return b.code
+}
+func (b *basicWriter) BytesWritten() int {
+	return b.bytes
+}
+func (b *basicWriter) Tee(w io.Writer) {
+	b.tee = w
+}
+func (b *basicWriter) Unwrap() http.ResponseWriter {
+	return b.ResponseWriter
+}
+
+type flushWriter struct {
+	basicWriter
+}
+
+func (f *flushWriter) Flush() {
+	fl := f.basicWriter.ResponseWriter.(http.Flusher)
+	fl.Flush()
+}
+
+var _ http.Flusher = &flushWriter{}
+
+// httpFancyWriter is a HTTP writer that additionally satisfies http.CloseNotifier,
+// http.Flusher, http.Hijacker, and io.ReaderFrom. It exists for the common case
+// of wrapping the http.ResponseWriter that package http gives you, in order to
+// make the proxied object support the full method set of the proxied object.
+type httpFancyWriter struct {
+	basicWriter
+}
+
+func (f *httpFancyWriter) CloseNotify() <-chan bool {
+	cn := f.basicWriter.ResponseWriter.(http.CloseNotifier)
+	return cn.CloseNotify()
+}
+func (f *httpFancyWriter) Flush() {
+	fl := f.basicWriter.ResponseWriter.(http.Flusher)
+	fl.Flush()
+}
+func (f *httpFancyWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hj := f.basicWriter.ResponseWriter.(http.Hijacker)
+	return hj.Hijack()
+}
+func (f *httpFancyWriter) ReadFrom(r io.Reader) (int64, error) {
+	if f.basicWriter.tee != nil {
+		return io.Copy(&f.basicWriter, r)
+	}
+	rf := f.basicWriter.ResponseWriter.(io.ReaderFrom)
+	f.basicWriter.maybeWriteHeader()
+	return rf.ReadFrom(r)
+}
+
+var _ http.CloseNotifier = &httpFancyWriter{}
+var _ http.Flusher = &httpFancyWriter{}
+var _ http.Hijacker = &httpFancyWriter{}
+var _ io.ReaderFrom = &httpFancyWriter{}
+
+// http2FancyWriter is a HTTP2 writer that additionally satisfies http.CloseNotifier,
+// http.Flusher, and io.ReaderFrom. It exists for the common case
+// of wrapping the http.ResponseWriter that package http gives you, in order to
+// make the proxied object support the full method set of the proxied object.
+type http2FancyWriter struct {
+	basicWriter
+}
+
+func (f *http2FancyWriter) CloseNotify() <-chan bool {
+	cn := f.basicWriter.ResponseWriter.(http.CloseNotifier)
+	return cn.CloseNotify()
+}
+func (f *http2FancyWriter) Flush() {
+	fl := f.basicWriter.ResponseWriter.(http.Flusher)
+	fl.Flush()
+}
+
+var _ http.CloseNotifier = &http2FancyWriter{}
+var _ http.Flusher = &http2FancyWriter{}

vendor/github.com/pressly/chi/middleware/wrap_writer17.go

@@ -0,0 +1,34 @@
+// +build go1.7,!go1.8
+
+package middleware
+
+import (
+	"io"
+	"net/http"
+)
+
+// NewWrapResponseWriter wraps an http.ResponseWriter, returning a proxy that allows you to
+// hook into various parts of the response process.
+func NewWrapResponseWriter(w http.ResponseWriter, protoMajor int) WrapResponseWriter {
+	_, cn := w.(http.CloseNotifier)
+	_, fl := w.(http.Flusher)
+
+	bw := basicWriter{ResponseWriter: w}
+
+	if protoMajor == 2 {
+		if cn && fl {
+			return &http2FancyWriter{bw}
+		}
+	} else {
+		_, hj := w.(http.Hijacker)
+		_, rf := w.(io.ReaderFrom)
+		if cn && fl && hj && rf {
+			return &httpFancyWriter{bw}
+		}
+	}
+	if fl {
+		return &flushWriter{bw}
+	}
+
+	return &bw
+}

vendor/github.com/pressly/chi/middleware/wrap_writer18.go

@@ -0,0 +1,41 @@
+// +build go1.8
+
+package middleware
+
+import (
+	"io"
+	"net/http"
+)
+
+// NewWrapResponseWriter wraps an http.ResponseWriter, returning a proxy that allows you to
+// hook into various parts of the response process.
+func NewWrapResponseWriter(w http.ResponseWriter, protoMajor int) WrapResponseWriter {
+	_, cn := w.(http.CloseNotifier)
+	_, fl := w.(http.Flusher)
+
+	bw := basicWriter{ResponseWriter: w}
+
+	if protoMajor == 2 {
+		_, ps := w.(http.Pusher)
+		if cn && fl && ps {
+			return &http2FancyWriter{bw}
+		}
+	} else {
+		_, hj := w.(http.Hijacker)
+		_, rf := w.(io.ReaderFrom)
+		if cn && fl && hj && rf {
+			return &httpFancyWriter{bw}
+		}
+	}
+	if fl {
+		return &flushWriter{bw}
+	}
+
+	return &bw
+}
+
+func (f *http2FancyWriter) Push(target string, opts *http.PushOptions) error {
+	return f.basicWriter.ResponseWriter.(http.Pusher).Push(target, opts)
+}
+
+var _ http.Pusher = &http2FancyWriter{}

vendor/github.com/pressly/chi/mux.go

@@ -0,0 +1,408 @@
+package chi
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+)
+
+var _ Router = &Mux{}
+
+// Mux is a simple HTTP route multiplexer that parses a request path,
+// records any URL params, and executes an end handler. It implements
+// the http.Handler interface and is friendly with the standard library.
+//
+// Mux is designed to be fast, minimal and offer a powerful API for building
+// modular and composable HTTP services with a large set of handlers. It's
+// particularly useful for writing large REST API services that break a handler
+// into many smaller parts composed of middlewares and end handlers.
+type Mux struct {
+	// The radix trie router
+	tree *node
+
+	// The middleware stack
+	middlewares []func(http.Handler) http.Handler
+
+	// Controls the behaviour of middleware chain generation when a mux
+	// is registered as an inline group inside another mux.
+	inline bool
+
+	// The computed mux handler made of the chained middleware stack and
+	// the tree router
+	handler http.Handler
+
+	// Routing context pool
+	pool sync.Pool
+
+	// Custom route not found handler
+	notFoundHandler http.HandlerFunc
+
+	// Custom method not allowed handler
+	methodNotAllowedHandler http.HandlerFunc
+}
+
+// NewMux returns a newly initialized Mux object that implements the Router
+// interface.
+func NewMux() *Mux {
+	mux := &Mux{tree: &node{}}
+	mux.pool.New = func() interface{} {
+		return NewRouteContext()
+	}
+	return mux
+}
+
+// ServeHTTP is the single method of the http.Handler interface that makes
+// Mux interoperable with the standard library. It uses a sync.Pool to get and
+// reuse routing contexts for each request.
+func (mx *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Ensure the mux has some routes defined on the mux
+	if mx.handler == nil {
+		panic("chi: attempting to route to a mux with no handlers.")
+	}
+
+	// Check if a routing context already exists from a parent router.
+	rctx, _ := r.Context().Value(RouteCtxKey).(*Context)
+	if rctx != nil {
+		mx.handler.ServeHTTP(w, r)
+		return
+	}
+
+	// Fetch a RouteContext object from the sync pool, and call the computed
+	// mx.handler that is comprised of mx.middlewares + mx.routeHTTP.
+	// Once the request is finished, reset the routing context and put it back
+	// into the pool for reuse from another request.
+	rctx = mx.pool.Get().(*Context)
+	rctx.reset()
+	r = r.WithContext(context.WithValue(r.Context(), RouteCtxKey, rctx))
+	mx.handler.ServeHTTP(w, r)
+	mx.pool.Put(rctx)
+}
+
+// Use appends a middleware handler to the Mux middleware stack.
+//
+// The middleware stack for any Mux will execute before searching for a matching
+// route to a specific handler, which provides opportunity to respond early,
+// change the course of the request execution, or set request-scoped values for
+// the next http.Handler.
+func (mx *Mux) Use(middlewares ...func(http.Handler) http.Handler) {
+	if mx.handler != nil {
+		panic("chi: all middlewares must be defined before routes on a mux")
+	}
+	mx.middlewares = append(mx.middlewares, middlewares...)
+}
+
+// Handle adds the route `pattern` that matches any http method to
+// execute the `handler` http.Handler.
+func (mx *Mux) Handle(pattern string, handler http.Handler) {
+	mx.handle(mALL, pattern, handler)
+}
+
+// HandleFunc adds the route `pattern` that matches any http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) HandleFunc(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mALL, pattern, handlerFn)
+}
+
+// Connect adds the route `pattern` that matches a CONNECT http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Connect(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mCONNECT, pattern, handlerFn)
+}
+
+// Delete adds the route `pattern` that matches a DELETE http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Delete(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mDELETE, pattern, handlerFn)
+}
+
+// Get adds the route `pattern` that matches a GET http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Get(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mGET, pattern, handlerFn)
+}
+
+// Head adds the route `pattern` that matches a HEAD http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Head(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mHEAD, pattern, handlerFn)
+}
+
+// Options adds the route `pattern` that matches a OPTIONS http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Options(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mOPTIONS, pattern, handlerFn)
+}
+
+// Patch adds the route `pattern` that matches a PATCH http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Patch(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mPATCH, pattern, handlerFn)
+}
+
+// Post adds the route `pattern` that matches a POST http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Post(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mPOST, pattern, handlerFn)
+}
+
+// Put adds the route `pattern` that matches a PUT http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Put(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mPUT, pattern, handlerFn)
+}
+
+// Trace adds the route `pattern` that matches a TRACE http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Trace(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mTRACE, pattern, handlerFn)
+}
+
+// NotFound sets a custom http.HandlerFunc for routing paths that could
+// not be found. The default 404 handler is `http.NotFound`.
+func (mx *Mux) NotFound(handlerFn http.HandlerFunc) {
+	mx.notFoundHandler = handlerFn
+
+	mx.updateSubRoutes(func(subMux *Mux) {
+		if subMux.notFoundHandler == nil {
+			subMux.NotFound(handlerFn)
+		}
+	})
+}
+
+// MethodNotAllowed sets a custom http.HandlerFunc for routing paths where the
+// method is unresolved. The default handler returns a 405 with an empty body.
+func (mx *Mux) MethodNotAllowed(handlerFn http.HandlerFunc) {
+	mx.methodNotAllowedHandler = handlerFn
+
+	mx.updateSubRoutes(func(subMux *Mux) {
+		if subMux.methodNotAllowedHandler == nil {
+			subMux.MethodNotAllowed(handlerFn)
+		}
+	})
+}
+
+// With adds inline middlewares for an endpoint handler.
+func (mx *Mux) With(middlewares ...func(http.Handler) http.Handler) Router {
+	// Similarly as in handle(), we must build the mux handler once further
+	// middleware registration isn't allowed for this stack, like now.
+	if !mx.inline && mx.handler == nil {
+		mx.buildRouteHandler()
+	}
+
+	// Copy middlewares from parent inline muxs
+	var mws Middlewares
+	if mx.inline {
+		mws = make(Middlewares, len(mx.middlewares))
+		copy(mws, mx.middlewares)
+	}
+	mws = append(mws, middlewares...)
+
+	im := &Mux{inline: true, tree: mx.tree, middlewares: mws}
+	return im
+}
+
+// Group creates a new inline-Mux with a fresh middleware stack. It's useful
+// for a group of handlers along the same routing path that use an additional
+// set of middlewares. See _examples/.
+func (mx *Mux) Group(fn func(r Router)) Router {
+	im := mx.With().(*Mux)
+	if fn != nil {
+		fn(im)
+	}
+	return im
+}
+
+// Route creates a new Mux with a fresh middleware stack and mounts it
+// along the `pattern` as a subrouter. Effectively, this is a short-hand
+// call to Mount. See _examples/.
+func (mx *Mux) Route(pattern string, fn func(r Router)) Router {
+	subRouter := NewRouter()
+	if fn != nil {
+		fn(subRouter)
+	}
+	mx.Mount(pattern, subRouter)
+	return subRouter
+}
+
+// Mount attaches another http.Handler or chi Router as a subrouter along a routing
+// path. It's very useful to split up a large API as many independent routers and
+// compose them as a single service using Mount. See _examples/.
+//
+// Note that Mount() simply sets a wildcard along the `pattern` that will continue
+// routing at the `handler`, which in most cases is another chi.Router. As a result,
+// if you define two Mount() routes on the exact same pattern the mount will panic.
+func (mx *Mux) Mount(pattern string, handler http.Handler) {
+	// Provide runtime safety for ensuring a pattern isn't mounted on an existing
+	// routing pattern.
+	if mx.tree.findPattern(pattern+"*") != nil || mx.tree.findPattern(pattern+"/*") != nil {
+		panic(fmt.Sprintf("chi: attempting to Mount() a handler on an existing path, '%s'", pattern))
+	}
+
+	// Assign sub-Router's with the parent not found & method not allowed handler if not specified.
+	subr, ok := handler.(*Mux)
+	if ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil {
+		subr.NotFound(mx.notFoundHandler)
+	}
+	if ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil {
+		subr.MethodNotAllowed(mx.methodNotAllowedHandler)
+	}
+
+	// Wrap the sub-router in a handlerFunc to scope the request path for routing.
+	subHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rctx := RouteContext(r.Context())
+		rctx.RoutePath = "/" + rctx.URLParams.Del("*")
+		handler.ServeHTTP(w, r)
+	})
+
+	if pattern == "" || pattern[len(pattern)-1] != '/' {
+		mx.handle(mALL|mSTUB, pattern, subHandler)
+		mx.handle(mALL|mSTUB, pattern+"/", mx.NotFoundHandler())
+		pattern += "/"
+	}
+
+	method := mALL
+	subroutes, _ := handler.(Routes)
+	if subroutes != nil {
+		method |= mSTUB
+	}
+	n := mx.handle(method, pattern+"*", subHandler)
+
+	if subroutes != nil {
+		n.subroutes = subroutes
+	}
+}
+
+func (mx *Mux) Middlewares() Middlewares {
+	return mx.middlewares
+}
+
+func (mx *Mux) Routes() []Route {
+	return mx.tree.routes()
+}
+
+// FileServer conveniently sets up a http.FileServer handler to serve
+// static files from a http.FileSystem.
+func (mx *Mux) FileServer(path string, root http.FileSystem) {
+	if strings.ContainsAny(path, ":*") {
+		panic("chi: FileServer does not permit URL parameters.")
+	}
+
+	fs := http.StripPrefix(path, http.FileServer(root))
+
+	if path != "/" && path[len(path)-1] != '/' {
+		mx.Get(path, http.RedirectHandler(path+"/", 301).ServeHTTP)
+		path += "/"
+	}
+	path += "*"
+
+	mx.Get(path, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fs.ServeHTTP(w, r)
+	}))
+}
+
+// NotFoundHandler returns the default Mux 404 responder whenever a route
+// cannot be found.
+func (mx *Mux) NotFoundHandler() http.HandlerFunc {
+	if mx.notFoundHandler != nil {
+		return mx.notFoundHandler
+	}
+	return http.NotFound
+}
+
+// MethodNotAllowedHandler returns the default Mux 405 responder whenever
+// a method cannot be resolved for a route.
+func (mx *Mux) MethodNotAllowedHandler() http.HandlerFunc {
+	if mx.methodNotAllowedHandler != nil {
+		return mx.methodNotAllowedHandler
+	}
+	return methodNotAllowedHandler
+}
+
+// buildRouteHandler builds the single mux handler that is a chain of the middleware
+// stack, as defined by calls to Use(), and the tree router (Mux) itself. After this
+// point, no other middlewares can be registered on this Mux's stack. But you can still
+// compose additional middlewares via Group()'s or using a chained middleware handler.
+func (mx *Mux) buildRouteHandler() {
+	mx.handler = chain(mx.middlewares, http.HandlerFunc(mx.routeHTTP))
+}
+
+// handle registers a http.Handler in the routing tree for a particular http method
+// and routing pattern.
+func (mx *Mux) handle(method methodTyp, pattern string, handler http.Handler) *node {
+	if len(pattern) == 0 || pattern[0] != '/' {
+		panic(fmt.Sprintf("chi: routing pattern must begin with '/' in '%s'", pattern))
+	}
+
+	// Build the final routing handler for this Mux.
+	if !mx.inline && mx.handler == nil {
+		mx.buildRouteHandler()
+	}
+
+	// Build endpoint handler with inline middlewares for the route
+	var h http.Handler
+	if mx.inline {
+		mx.handler = http.HandlerFunc(mx.routeHTTP)
+		h = Chain(mx.middlewares...).Handler(handler)
+	} else {
+		h = handler
+	}
+
+	// Add the endpoint to the tree and return the node
+	return mx.tree.InsertRoute(method, pattern, h)
+}
+
+// routeHTTP routes a http.Request through the Mux routing tree to serve
+// the matching handler for a particular http method.
+func (mx *Mux) routeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Grab the route context object
+	rctx := r.Context().Value(RouteCtxKey).(*Context)
+
+	// The request routing path
+	routePath := rctx.RoutePath
+	if routePath == "" {
+		routePath = r.URL.Path
+	}
+
+	// Check if method is supported by chi
+	method, ok := methodMap[r.Method]
+	if !ok {
+		mx.MethodNotAllowedHandler().ServeHTTP(w, r)
+		return
+	}
+
+	// Find the route
+	hs := mx.tree.FindRoute(rctx, routePath)
+	if hs == nil {
+		mx.NotFoundHandler().ServeHTTP(w, r)
+		return
+	}
+
+	h, ok := hs[method]
+	if !ok {
+		mx.MethodNotAllowedHandler().ServeHTTP(w, r)
+		return
+	}
+
+	// Serve it up
+	h.ServeHTTP(w, r)
+}
+
+// Recursively update data on child routers.
+func (mx *Mux) updateSubRoutes(fn func(subMux *Mux)) {
+	for _, r := range mx.tree.routes() {
+		subMux, ok := r.SubRoutes.(*Mux)
+		if !ok {
+			continue
+		}
+		fn(subMux)
+	}
+}
+
+// methodNotAllowedHandler is a helper function to respond with a 405,
+// method not allowed.
+func methodNotAllowedHandler(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(405)
+	w.Write(nil)
+}

vendor/github.com/pressly/chi/tree.go

@@ -0,0 +1,535 @@
+package chi
+
+// Radix tree implementation below is a based on the original work by
+// Armon Dadgar in https://github.com/armon/go-radix/blob/master/radix.go
+// (MIT licensed). It's been heavily modified for use as a HTTP routing tree.
+
+import (
+	"net/http"
+	"sort"
+	"strings"
+)
+
+type methodTyp int
+
+const (
+	mCONNECT methodTyp = 1 << iota
+	mDELETE
+	mGET
+	mHEAD
+	mOPTIONS
+	mPATCH
+	mPOST
+	mPUT
+	mTRACE
+	mSTUB
+
+	mALL methodTyp = mCONNECT | mDELETE | mGET | mHEAD | mOPTIONS |
+		mPATCH | mPOST | mPUT | mTRACE
+)
+
+var methodMap = map[string]methodTyp{
+	"CONNECT": mCONNECT,
+	"DELETE":  mDELETE,
+	"GET":     mGET,
+	"HEAD":    mHEAD,
+	"OPTIONS": mOPTIONS,
+	"PATCH":   mPATCH,
+	"POST":    mPOST,
+	"PUT":     mPUT,
+	"TRACE":   mTRACE,
+}
+
+type nodeTyp uint8
+
+const (
+	ntStatic   nodeTyp = iota // /home
+	ntRegexp                  // /:id([0-9]+) or #id^[0-9]+$
+	ntParam                   // /:user
+	ntCatchAll                // /api/v1/*
+)
+
+type node struct {
+	// node type
+	typ nodeTyp
+
+	// first byte of the prefix
+	label byte
+
+	// prefix is the common prefix we ignore
+	prefix string
+
+	// pattern is the computed path of prefixes
+	pattern string
+
+	// HTTP handler on the leaf node
+	handlers methodHandlers
+
+	// chi subroutes on the leaf node
+	subroutes Routes
+
+	// Child nodes should be stored in-order for iteration,
+	// in groups of the node type.
+	children [ntCatchAll + 1]nodes
+}
+
+func (n *node) FindRoute(rctx *Context, path string) methodHandlers {
+	// Reset the context routing pattern
+	rctx.RoutePattern = ""
+
+	// Find the routing handlers for the path
+	rn := n.findRoute(rctx, path)
+	if rn == nil {
+		return nil
+	}
+
+	// Record the routing pattern in the request lifecycle
+	if rn.pattern != "" {
+		rctx.RoutePattern = rn.pattern
+		rctx.RoutePatterns = append(rctx.RoutePatterns, rctx.RoutePattern)
+	}
+
+	return rn.handlers
+}
+
+func (n *node) InsertRoute(method methodTyp, pattern string, handler http.Handler) *node {
+	var parent *node
+	search := pattern
+
+	for {
+		// Handle key exhaustion
+		if len(search) == 0 {
+			// Insert or update the node's leaf handler
+			n.setHandler(method, handler)
+			n.pattern = pattern
+			return n
+		}
+
+		// Look for the edge
+		parent = n
+		n = n.getEdge(search[0])
+
+		// No edge, create one
+		if n == nil {
+			cn := &node{label: search[0], prefix: search, pattern: pattern}
+			cn.setHandler(method, handler)
+			parent.addChild(pattern, cn)
+			return cn
+		}
+
+		if n.typ > ntStatic {
+			// We found a wildcard node, meaning search path starts with
+			// a wild prefix. Trim off the wildcard search path and continue.
+			p := strings.Index(search, "/")
+			if p < 0 {
+				p = len(search)
+			}
+			search = search[p:]
+			continue
+		}
+
+		// Static nodes fall below here.
+		// Determine longest prefix of the search key on match.
+		commonPrefix := n.longestPrefix(search, n.prefix)
+		if commonPrefix == len(n.prefix) {
+			// the common prefix is as long as the current node's prefix we're attempting to insert.
+			// keep the search going.
+			search = search[commonPrefix:]
+			continue
+		}
+
+		// Split the node
+		child := &node{
+			typ:    ntStatic,
+			prefix: search[:commonPrefix],
+		}
+		parent.replaceChild(search[0], child)
+
+		// Restore the existing node
+		n.label = n.prefix[commonPrefix]
+		n.prefix = n.prefix[commonPrefix:]
+		child.addChild(pattern, n)
+
+		// If the new key is a subset, add to to this node
+		search = search[commonPrefix:]
+		if len(search) == 0 {
+			child.setHandler(method, handler)
+			child.pattern = pattern
+			return child
+		}
+
+		// Create a new edge for the node
+		subchild := &node{
+			typ:     ntStatic,
+			label:   search[0],
+			prefix:  search,
+			pattern: pattern,
+		}
+		subchild.setHandler(method, handler)
+		child.addChild(pattern, subchild)
+		return subchild
+	}
+}
+
+func (n *node) findPattern(pattern string) *node {
+	nn := n
+	for _, nds := range nn.children {
+		if len(nds) == 0 {
+			continue
+		}
+
+		n = nn.getEdge(pattern[0])
+		if n == nil {
+			continue
+		}
+
+		idx := n.longestPrefix(pattern, n.prefix)
+		xpattern := pattern[idx:]
+
+		if len(xpattern) == 0 {
+			return n
+		} else if xpattern[0] == '/' && idx < len(n.prefix) {
+			continue
+		}
+
+		return n.findPattern(xpattern)
+	}
+	return nil
+}
+
+func (n *node) isLeaf() bool {
+	return n.handlers != nil
+}
+
+func (n *node) addChild(pattern string, child *node) {
+	search := child.prefix
+
+	// Find any wildcard segments
+	p := strings.IndexAny(search, ":*")
+
+	// Determine new node type
+	ntyp := child.typ
+	if p >= 0 {
+		switch search[p] {
+		case ':':
+			ntyp = ntParam
+		case '*':
+			ntyp = ntCatchAll
+		}
+	}
+
+	if p == 0 {
+		// Path starts with a wildcard
+
+		handlers := child.handlers
+		child.typ = ntyp
+
+		if ntyp == ntCatchAll {
+			p = -1
+		} else {
+			p = strings.IndexByte(search, '/')
+		}
+		if p < 0 {
+			p = len(search)
+		}
+		child.prefix = search[:p]
+
+		if p != len(search) {
+			// add edge for the remaining part, split the end.
+			child.handlers = nil
+
+			search = search[p:]
+
+			child.addChild(pattern, &node{
+				typ:      ntStatic,
+				label:    search[0], // this will always start with /
+				prefix:   search,
+				pattern:  pattern,
+				handlers: handlers,
+			})
+		}
+
+	} else if p > 0 {
+		// Path has some wildcard
+
+		// starts with a static segment
+		handlers := child.handlers
+		child.typ = ntStatic
+		child.prefix = search[:p]
+		child.handlers = nil
+
+		// add the wild edge node
+		search = search[p:]
+
+		child.addChild(pattern, &node{
+			typ:      ntyp,
+			label:    search[0],
+			prefix:   search,
+			pattern:  pattern,
+			handlers: handlers,
+		})
+
+	} else {
+		// Path is all static
+		child.typ = ntyp
+
+	}
+
+	n.children[child.typ] = append(n.children[child.typ], child)
+	n.children[child.typ].Sort()
+}
+
+func (n *node) replaceChild(label byte, child *node) {
+	for i := 0; i < len(n.children[child.typ]); i++ {
+		if n.children[child.typ][i].label == label {
+			n.children[child.typ][i] = child
+			n.children[child.typ][i].label = label
+			return
+		}
+	}
+
+	panic("chi: replacing missing child")
+}
+
+func (n *node) getEdge(label byte) *node {
+	for _, nds := range n.children {
+		num := len(nds)
+		for i := 0; i < num; i++ {
+			if nds[i].label == label {
+				return nds[i]
+			}
+		}
+	}
+	return nil
+}
+
+func (n *node) findEdge(ntyp nodeTyp, label byte) *node {
+	nds := n.children[ntyp]
+	num := len(nds)
+	idx := 0
+
+	switch ntyp {
+	case ntStatic:
+		i, j := 0, num-1
+		for i <= j {
+			idx = i + (j-i)/2
+			if label > nds[idx].label {
+				i = idx + 1
+			} else if label < nds[idx].label {
+				j = idx - 1
+			} else {
+				i = num // breaks cond
+			}
+		}
+		if nds[idx].label != label {
+			return nil
+		}
+		return nds[idx]
+
+	default: // wild nodes
+		// TODO: right now we match them all.. but regexp should
+		// run through regexp matcher
+		return nds[idx]
+	}
+}
+
+// Recursive edge traversal by checking all nodeTyp groups along the way.
+// It's like searching through a multi-dimensional radix trie.
+func (n *node) findRoute(rctx *Context, path string) *node {
+	nn := n
+	search := path
+
+	for t, nds := range nn.children {
+		ntyp := nodeTyp(t)
+		if len(nds) == 0 {
+			continue
+		}
+
+		// search subset of edges of the index for a matching node
+		var label byte
+		if search != "" {
+			label = search[0]
+		}
+
+		xn := nn.findEdge(ntyp, label) // next node
+		if xn == nil {
+			continue
+		}
+
+		// Prepare next search path by trimming prefix from requested path
+		xsearch := search
+		if xn.typ > ntStatic {
+			p := -1
+			if xn.typ < ntCatchAll {
+				p = strings.IndexByte(xsearch, '/')
+			}
+			if p < 0 {
+				p = len(xsearch)
+			}
+
+			if xn.typ == ntCatchAll {
+				rctx.URLParams.Add("*", xsearch)
+			} else {
+				rctx.URLParams.Add(xn.prefix[1:], xsearch[:p])
+			}
+
+			xsearch = xsearch[p:]
+		} else if strings.HasPrefix(xsearch, xn.prefix) {
+			xsearch = xsearch[len(xn.prefix):]
+		} else {
+			continue // no match
+		}
+
+		// did we find it yet?
+		if len(xsearch) == 0 {
+			if xn.isLeaf() {
+				return xn
+			}
+		}
+
+		// recursively find the next node..
+		fin := xn.findRoute(rctx, xsearch)
+		if fin != nil {
+			// found a node, return it
+			return fin
+		}
+
+		// Did not found final handler, let's remove the param here if it was set
+		if xn.typ > ntStatic {
+			if xn.typ == ntCatchAll {
+				rctx.URLParams.Del("*")
+			} else {
+				rctx.URLParams.Del(xn.prefix[1:])
+			}
+		}
+	}
+
+	return nil
+}
+
+// longestPrefix finds the length of the shared prefix
+// of two strings
+func (n *node) 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
+}
+
+func (n *node) setHandler(method methodTyp, handler http.Handler) {
+	if n.handlers == nil {
+		n.handlers = make(methodHandlers, 0)
+	}
+	if method&mSTUB == mSTUB {
+		n.handlers[mSTUB] = handler
+	} else {
+		n.handlers[mSTUB] = nil
+	}
+	if method&mALL == mALL {
+		n.handlers[mALL] = handler
+		for _, m := range methodMap {
+			n.handlers[m] = handler
+		}
+	} else {
+		n.handlers[method] = handler
+	}
+}
+
+func (n *node) isEmpty() bool {
+	for _, nds := range n.children {
+		if len(nds) > 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func (n *node) routes() []Route {
+	rts := []Route{}
+
+	n.walkRoutes(n.prefix, n, func(pattern string, handlers methodHandlers, subroutes Routes) bool {
+		if handlers[mSTUB] != nil && subroutes == nil {
+			return false
+		}
+
+		if subroutes != nil && len(pattern) > 2 {
+			pattern = pattern[:len(pattern)-2]
+		}
+
+		var hs = make(map[string]http.Handler, 0)
+		if handlers[mALL] != nil {
+			hs["*"] = handlers[mALL]
+		}
+		for mt, h := range handlers {
+			if h == nil {
+				continue
+			}
+			m := methodTypString(mt)
+			if m == "" {
+				continue
+			}
+			hs[m] = h
+		}
+
+		rt := Route{pattern, hs, subroutes}
+		rts = append(rts, rt)
+		return false
+	})
+
+	return rts
+}
+
+func (n *node) walkRoutes(pattern string, nd *node, fn walkFn) bool {
+	pattern = nd.pattern
+
+	// Visit the leaf values if any
+	if (nd.handlers != nil || nd.subroutes != nil) && fn(pattern, nd.handlers, nd.subroutes) {
+		return true
+	}
+
+	// Recurse on the children
+	for _, nds := range nd.children {
+		for _, nd := range nds {
+			if n.walkRoutes(pattern, nd, fn) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func methodTypString(method methodTyp) string {
+	for s, t := range methodMap {
+		if method == t {
+			return s
+		}
+	}
+	return ""
+}
+
+type walkFn func(pattern string, handlers methodHandlers, subroutes Routes) bool
+
+// methodHandlers is a mapping of http method constants to handlers
+// for a given route.
+type methodHandlers map[methodTyp]http.Handler
+
+type nodes []*node
+
+// Sort the list of nodes by label
+func (ns nodes) Len() int           { return len(ns) }
+func (ns nodes) Less(i, j int) bool { return ns[i].label < ns[j].label }
+func (ns nodes) Swap(i, j int)      { ns[i], ns[j] = ns[j], ns[i] }
+func (ns nodes) Sort()              { sort.Sort(ns) }
+
+type Route struct {
+	Pattern   string
+	Handlers  map[string]http.Handler
+	SubRoutes Routes
+}

vendor/github.com/tidwall/btree/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/tidwall/btree/README.md

@@ -0,0 +1,107 @@
+BTree implementation for Go
+===========================
+
+![Travis CI Build Status](https://api.travis-ci.org/tidwall/btree.svg?branch=master)
+[![GoDoc](https://godoc.org/github.com/tidwall/btree?status.svg)](https://godoc.org/github.com/tidwall/btree)
+
+This package provides an in-memory B-Tree implementation for Go, useful as
+an ordered, mutable data structure.
+
+This is a fork of the wonderful [google/btree](https://github.com/google/btree) package. It's has all the same great features and adds a few more.
+
+- Descend* functions for iterating backwards.
+- Iteration performance boost.
+- User defined context.
+
+User defined context
+--------------------
+This is a great new feature that allows for entering the same item into multiple B-trees, and each B-tree have a different ordering formula.
+
+For example:
+
+```go
+package main
+
+import (
+	"fmt"
+
+	"github.com/tidwall/btree"
+)
+
+type Item struct {
+	Key, Val string
+}
+
+func (i1 *Item) Less(item btree.Item, ctx interface{}) bool {
+	i2 := item.(*Item)
+	switch tag := ctx.(type) {
+	case string:
+		if tag == "vals" {
+			if i1.Val < i2.Val {
+				return true
+			} else if i1.Val > i2.Val {
+				return false
+			}
+			// Both vals are equal so we should fall though
+			// and let the key comparison take over.
+		}
+	}
+	return i1.Key < i2.Key
+}
+
+func main() {
+
+	// Create a tree for keys and a tree for values.
+	// The "keys" tree will be sorted on the Keys field.
+	// The "values" tree will be sorted on the Values field.
+	keys := btree.New(16, "keys")
+	vals := btree.New(16, "vals")
+
+	// Create some items.
+	users := []*Item{
+		&Item{Key: "user:1", Val: "Jane"},
+		&Item{Key: "user:2", Val: "Andy"},
+		&Item{Key: "user:3", Val: "Steve"},
+		&Item{Key: "user:4", Val: "Andrea"},
+		&Item{Key: "user:5", Val: "Janet"},
+		&Item{Key: "user:6", Val: "Andy"},
+	}
+
+	// Insert each user into both trees
+	for _, user := range users {
+		keys.ReplaceOrInsert(user)
+		vals.ReplaceOrInsert(user)
+	}
+
+	// Iterate over each user in the key tree
+	keys.Ascend(func(item btree.Item) bool {
+		kvi := item.(*Item)
+		fmt.Printf("%s %s\n", kvi.Key, kvi.Val)
+		return true
+	})
+
+	fmt.Printf("\n")
+	// Iterate over each user in the val tree
+	vals.Ascend(func(item btree.Item) bool {
+		kvi := item.(*Item)
+		fmt.Printf("%s %s\n", kvi.Key, kvi.Val)
+		return true
+	})
+}
+
+// Should see the results
+/*
+user:1 Jane
+user:2 Andy
+user:3 Steve
+user:4 Andrea
+user:5 Janet
+user:6 Andy
+
+user:4 Andrea
+user:2 Andy
+user:6 Andy
+user:1 Jane
+user:3 Steve
+*/
+```

vendor/github.com/tidwall/btree/btree.go

@@ -0,0 +1,968 @@
+// Copyright 2014 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package btree implements in-memory B-Trees of arbitrary degree.
+//
+// btree implements an in-memory B-Tree for use as an ordered data structure.
+// It is not meant for persistent storage solutions.
+//
+// It has a flatter structure than an equivalent red-black or other binary tree,
+// which in some cases yields better memory usage and/or performance.
+// See some discussion on the matter here:
+//   http://google-opensource.blogspot.com/2013/01/c-containers-that-save-memory-and-time.html
+// Note, though, that this project is in no way related to the C++ B-Tree
+// implementation written about there.
+//
+// Within this tree, each node contains a slice of items and a (possibly nil)
+// slice of children.  For basic numeric values or raw structs, this can cause
+// efficiency differences when compared to equivalent C++ template code that
+// stores values in arrays within the node:
+//   * Due to the overhead of storing values as interfaces (each
+//     value needs to be stored as the value itself, then 2 words for the
+//     interface pointing to that value and its type), resulting in higher
+//     memory use.
+//   * Since interfaces can point to values anywhere in memory, values are
+//     most likely not stored in contiguous blocks, resulting in a higher
+//     number of cache misses.
+// These issues don't tend to matter, though, when working with strings or other
+// heap-allocated structures, since C++-equivalent structures also must store
+// pointers and also distribute their values across the heap.
+//
+// This implementation is designed to be a drop-in replacement to gollrb.LLRB
+// trees, (http://github.com/petar/gollrb), an excellent and probably the most
+// widely used ordered tree implementation in the Go ecosystem currently.
+// Its functions, therefore, exactly mirror those of
+// llrb.LLRB where possible.  Unlike gollrb, though, we currently don't
+// support storing multiple equivalent values.
+package btree
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+)
+
+// Item represents a single object in the tree.
+type Item interface {
+	// Less tests whether the current item is less than the given argument.
+	//
+	// This must provide a strict weak ordering.
+	// If !a.Less(b) && !b.Less(a), we treat this to mean a == b (i.e. we can only
+	// hold one of either a or b in the tree).
+	//
+	// There is a user-defined ctx argument that is equal to the ctx value which
+	// is set at time of the btree contruction.
+	Less(than Item, ctx interface{}) bool
+}
+
+const (
+	DefaultFreeListSize = 32
+)
+
+var (
+	nilItems    = make(items, 16)
+	nilChildren = make(children, 16)
+)
+
+// FreeList represents a free list of btree nodes. By default each
+// BTree has its own FreeList, but multiple BTrees can share the same
+// FreeList.
+// Two Btrees using the same freelist are safe for concurrent write access.
+type FreeList struct {
+	mu       sync.Mutex
+	freelist []*node
+}
+
+// NewFreeList creates a new free list.
+// size is the maximum size of the returned free list.
+func NewFreeList(size int) *FreeList {
+	return &FreeList{freelist: make([]*node, 0, size)}
+}
+
+func (f *FreeList) newNode() (n *node) {
+	f.mu.Lock()
+	index := len(f.freelist) - 1
+	if index < 0 {
+		f.mu.Unlock()
+		return new(node)
+	}
+	n = f.freelist[index]
+	f.freelist[index] = nil
+	f.freelist = f.freelist[:index]
+	f.mu.Unlock()
+	return
+}
+
+func (f *FreeList) freeNode(n *node) {
+	f.mu.Lock()
+	if len(f.freelist) < cap(f.freelist) {
+		f.freelist = append(f.freelist, n)
+	}
+	f.mu.Unlock()
+}
+
+// ItemIterator allows callers of Ascend* to iterate in-order over portions of
+// the tree.  When this function returns false, iteration will stop and the
+// associated Ascend* function will immediately return.
+type ItemIterator func(i Item) bool
+
+// New creates a new B-Tree with the given degree.
+//
+// New(2), for example, will create a 2-3-4 tree (each node contains 1-3 items
+// and 2-4 children).
+func New(degree int, ctx interface{}) *BTree {
+	return NewWithFreeList(degree, NewFreeList(DefaultFreeListSize), ctx)
+}
+
+// NewWithFreeList creates a new B-Tree that uses the given node free list.
+func NewWithFreeList(degree int, f *FreeList, ctx interface{}) *BTree {
+	if degree <= 1 {
+		panic("bad degree")
+	}
+	return &BTree{
+		degree: degree,
+		cow:    &copyOnWriteContext{freelist: f},
+		ctx:    ctx,
+	}
+}
+
+// items stores items in a node.
+type items []Item
+
+// insertAt inserts a value into the given index, pushing all subsequent values
+// forward.
+func (s *items) insertAt(index int, item Item) {
+	*s = append(*s, nil)
+	if index < len(*s) {
+		copy((*s)[index+1:], (*s)[index:])
+	}
+	(*s)[index] = item
+}
+
+// removeAt removes a value at a given index, pulling all subsequent values
+// back.
+func (s *items) removeAt(index int) Item {
+	item := (*s)[index]
+	copy((*s)[index:], (*s)[index+1:])
+	(*s)[len(*s)-1] = nil
+	*s = (*s)[:len(*s)-1]
+	return item
+}
+
+// pop removes and returns the last element in the list.
+func (s *items) pop() (out Item) {
+	index := len(*s) - 1
+	out = (*s)[index]
+	(*s)[index] = nil
+	*s = (*s)[:index]
+	return
+}
+
+// truncate truncates this instance at index so that it contains only the
+// first index items. index must be less than or equal to length.
+func (s *items) truncate(index int) {
+	var toClear items
+	*s, toClear = (*s)[:index], (*s)[index:]
+	for len(toClear) > 0 {
+		toClear = toClear[copy(toClear, nilItems):]
+	}
+}
+
+// find returns the index where the given item should be inserted into this
+// list.  'found' is true if the item already exists in the list at the given
+// index.
+func (s items) find(item Item, ctx interface{}) (index int, found bool) {
+	i, j := 0, len(s)
+	for i < j {
+		h := i + (j-i)/2
+		if !item.Less(s[h], ctx) {
+			i = h + 1
+		} else {
+			j = h
+		}
+	}
+	if i > 0 && !s[i-1].Less(item, ctx) {
+		return i - 1, true
+	}
+	return i, false
+}
+
+// children stores child nodes in a node.
+type children []*node
+
+// insertAt inserts a value into the given index, pushing all subsequent values
+// forward.
+func (s *children) insertAt(index int, n *node) {
+	*s = append(*s, nil)
+	if index < len(*s) {
+		copy((*s)[index+1:], (*s)[index:])
+	}
+	(*s)[index] = n
+}
+
+// removeAt removes a value at a given index, pulling all subsequent values
+// back.
+func (s *children) removeAt(index int) *node {
+	n := (*s)[index]
+	copy((*s)[index:], (*s)[index+1:])
+	(*s)[len(*s)-1] = nil
+	*s = (*s)[:len(*s)-1]
+	return n
+}
+
+// pop removes and returns the last element in the list.
+func (s *children) pop() (out *node) {
+	index := len(*s) - 1
+	out = (*s)[index]
+	(*s)[index] = nil
+	*s = (*s)[:index]
+	return
+}
+
+// truncate truncates this instance at index so that it contains only the
+// first index children. index must be less than or equal to length.
+func (s *children) truncate(index int) {
+	var toClear children
+	*s, toClear = (*s)[:index], (*s)[index:]
+	for len(toClear) > 0 {
+		toClear = toClear[copy(toClear, nilChildren):]
+	}
+}
+
+// node is an internal node in a tree.
+//
+// It must at all times maintain the invariant that either
+//   * len(children) == 0, len(items) unconstrained
+//   * len(children) == len(items) + 1
+type node struct {
+	items    items
+	children children
+	cow      *copyOnWriteContext
+}
+
+func (n *node) mutableFor(cow *copyOnWriteContext) *node {
+	if n.cow == cow {
+		return n
+	}
+	out := cow.newNode()
+	if cap(out.items) >= len(n.items) {
+		out.items = out.items[:len(n.items)]
+	} else {
+		out.items = make(items, len(n.items), cap(n.items))
+	}
+	copy(out.items, n.items)
+	// Copy children
+	if cap(out.children) >= len(n.children) {
+		out.children = out.children[:len(n.children)]
+	} else {
+		out.children = make(children, len(n.children), cap(n.children))
+	}
+	copy(out.children, n.children)
+	return out
+}
+
+func (n *node) mutableChild(i int) *node {
+	c := n.children[i].mutableFor(n.cow)
+	n.children[i] = c
+	return c
+}
+
+// split splits the given node at the given index.  The current node shrinks,
+// and this function returns the item that existed at that index and a new node
+// containing all items/children after it.
+func (n *node) split(i int) (Item, *node) {
+	item := n.items[i]
+	next := n.cow.newNode()
+	next.items = append(next.items, n.items[i+1:]...)
+	n.items.truncate(i)
+	if len(n.children) > 0 {
+		next.children = append(next.children, n.children[i+1:]...)
+		n.children.truncate(i + 1)
+	}
+	return item, next
+}
+
+// maybeSplitChild checks if a child should be split, and if so splits it.
+// Returns whether or not a split occurred.
+func (n *node) maybeSplitChild(i, maxItems int) bool {
+	if len(n.children[i].items) < maxItems {
+		return false
+	}
+	first := n.mutableChild(i)
+	item, second := first.split(maxItems / 2)
+	n.items.insertAt(i, item)
+	n.children.insertAt(i+1, second)
+	return true
+}
+
+// insert inserts an item into the subtree rooted at this node, making sure
+// no nodes in the subtree exceed maxItems items.  Should an equivalent item be
+// be found/replaced by insert, it will be returned.
+func (n *node) insert(item Item, maxItems int, ctx interface{}) Item {
+	i, found := n.items.find(item, ctx)
+	if found {
+		out := n.items[i]
+		n.items[i] = item
+		return out
+	}
+	if len(n.children) == 0 {
+		n.items.insertAt(i, item)
+		return nil
+	}
+	if n.maybeSplitChild(i, maxItems) {
+		inTree := n.items[i]
+		switch {
+		case item.Less(inTree, ctx):
+			// no change, we want first split node
+		case inTree.Less(item, ctx):
+			i++ // we want second split node
+		default:
+			out := n.items[i]
+			n.items[i] = item
+			return out
+		}
+	}
+	return n.mutableChild(i).insert(item, maxItems, ctx)
+}
+
+// get finds the given key in the subtree and returns it.
+func (n *node) get(key Item, ctx interface{}) Item {
+	i, found := n.items.find(key, ctx)
+	if found {
+		return n.items[i]
+	} else if len(n.children) > 0 {
+		return n.children[i].get(key, ctx)
+	}
+	return nil
+}
+
+// min returns the first item in the subtree.
+func min(n *node) Item {
+	if n == nil {
+		return nil
+	}
+	for len(n.children) > 0 {
+		n = n.children[0]
+	}
+	if len(n.items) == 0 {
+		return nil
+	}
+	return n.items[0]
+}
+
+// max returns the last item in the subtree.
+func max(n *node) Item {
+	if n == nil {
+		return nil
+	}
+	for len(n.children) > 0 {
+		n = n.children[len(n.children)-1]
+	}
+	if len(n.items) == 0 {
+		return nil
+	}
+	return n.items[len(n.items)-1]
+}
+
+// toRemove details what item to remove in a node.remove call.
+type toRemove int
+
+const (
+	removeItem toRemove = iota // removes the given item
+	removeMin                  // removes smallest item in the subtree
+	removeMax                  // removes largest item in the subtree
+)
+
+// remove removes an item from the subtree rooted at this node.
+func (n *node) remove(item Item, minItems int, typ toRemove, ctx interface{}) Item {
+	var i int
+	var found bool
+	switch typ {
+	case removeMax:
+		if len(n.children) == 0 {
+			return n.items.pop()
+		}
+		i = len(n.items)
+	case removeMin:
+		if len(n.children) == 0 {
+			return n.items.removeAt(0)
+		}
+		i = 0
+	case removeItem:
+		i, found = n.items.find(item, ctx)
+		if len(n.children) == 0 {
+			if found {
+				return n.items.removeAt(i)
+			}
+			return nil
+		}
+	default:
+		panic("invalid type")
+	}
+	// If we get to here, we have children.
+	if len(n.children[i].items) <= minItems {
+		return n.growChildAndRemove(i, item, minItems, typ, ctx)
+	}
+	child := n.mutableChild(i)
+	// Either we had enough items to begin with, or we've done some
+	// merging/stealing, because we've got enough now and we're ready to return
+	// stuff.
+	if found {
+		// The item exists at index 'i', and the child we've selected can give us a
+		// predecessor, since if we've gotten here it's got > minItems items in it.
+		out := n.items[i]
+		// We use our special-case 'remove' call with typ=maxItem to pull the
+		// predecessor of item i (the rightmost leaf of our immediate left child)
+		// and set it into where we pulled the item from.
+		n.items[i] = child.remove(nil, minItems, removeMax, ctx)
+		return out
+	}
+	// Final recursive call.  Once we're here, we know that the item isn't in this
+	// node and that the child is big enough to remove from.
+	return child.remove(item, minItems, typ, ctx)
+}
+
+// growChildAndRemove grows child 'i' to make sure it's possible to remove an
+// item from it while keeping it at minItems, then calls remove to actually
+// remove it.
+//
+// Most documentation says we have to do two sets of special casing:
+//   1) item is in this node
+//   2) item is in child
+// In both cases, we need to handle the two subcases:
+//   A) node has enough values that it can spare one
+//   B) node doesn't have enough values
+// For the latter, we have to check:
+//   a) left sibling has node to spare
+//   b) right sibling has node to spare
+//   c) we must merge
+// To simplify our code here, we handle cases #1 and #2 the same:
+// If a node doesn't have enough items, we make sure it does (using a,b,c).
+// We then simply redo our remove call, and the second time (regardless of
+// whether we're in case 1 or 2), we'll have enough items and can guarantee
+// that we hit case A.
+func (n *node) growChildAndRemove(i int, item Item, minItems int, typ toRemove, ctx interface{}) Item {
+	if i > 0 && len(n.children[i-1].items) > minItems {
+		// Steal from left child
+		child := n.mutableChild(i)
+		stealFrom := n.mutableChild(i - 1)
+		stolenItem := stealFrom.items.pop()
+		child.items.insertAt(0, n.items[i-1])
+		n.items[i-1] = stolenItem
+		if len(stealFrom.children) > 0 {
+			child.children.insertAt(0, stealFrom.children.pop())
+		}
+	} else if i < len(n.items) && len(n.children[i+1].items) > minItems {
+		// steal from right child
+		child := n.mutableChild(i)
+		stealFrom := n.mutableChild(i + 1)
+		stolenItem := stealFrom.items.removeAt(0)
+		child.items = append(child.items, n.items[i])
+		n.items[i] = stolenItem
+		if len(stealFrom.children) > 0 {
+			child.children = append(child.children, stealFrom.children.removeAt(0))
+		}
+	} else {
+		if i >= len(n.items) {
+			i--
+		}
+		child := n.mutableChild(i)
+		// merge with right child
+		mergeItem := n.items.removeAt(i)
+		mergeChild := n.children.removeAt(i + 1)
+		child.items = append(child.items, mergeItem)
+		child.items = append(child.items, mergeChild.items...)
+		child.children = append(child.children, mergeChild.children...)
+		n.cow.freeNode(mergeChild)
+	}
+	return n.remove(item, minItems, typ, ctx)
+}
+
+type direction int
+
+const (
+	descend = direction(-1)
+	ascend  = direction(+1)
+)
+
+// iterate provides a simple method for iterating over elements in the tree.
+//
+// When ascending, the 'start' should be less than 'stop' and when descending,
+// the 'start' should be greater than 'stop'. Setting 'includeStart' to true
+// will force the iterator to include the first item when it equals 'start',
+// thus creating a "greaterOrEqual" or "lessThanEqual" rather than just a
+// "greaterThan" or "lessThan" queries.
+func (n *node) iterate(dir direction, start, stop Item, includeStart bool, hit bool, iter ItemIterator, ctx interface{}) (bool, bool) {
+	var ok bool
+	switch dir {
+	case ascend:
+		for i := 0; i < len(n.items); i++ {
+			if start != nil && n.items[i].Less(start, ctx) {
+				continue
+			}
+			if len(n.children) > 0 {
+				if hit, ok = n.children[i].iterate(dir, start, stop, includeStart, hit, iter, ctx); !ok {
+					return hit, false
+				}
+			}
+			if !includeStart && !hit && start != nil && !start.Less(n.items[i], ctx) {
+				hit = true
+				continue
+			}
+			hit = true
+			if stop != nil && !n.items[i].Less(stop, ctx) {
+				return hit, false
+			}
+			if !iter(n.items[i]) {
+				return hit, false
+			}
+		}
+		if len(n.children) > 0 {
+			if hit, ok = n.children[len(n.children)-1].iterate(dir, start, stop, includeStart, hit, iter, ctx); !ok {
+				return hit, false
+			}
+		}
+	case descend:
+		for i := len(n.items) - 1; i >= 0; i-- {
+			if start != nil && !n.items[i].Less(start, ctx) {
+				if !includeStart || hit || start.Less(n.items[i], ctx) {
+					continue
+				}
+			}
+			if len(n.children) > 0 {
+				if hit, ok = n.children[i+1].iterate(dir, start, stop, includeStart, hit, iter, ctx); !ok {
+					return hit, false
+				}
+			}
+			if stop != nil && !stop.Less(n.items[i], ctx) {
+				return hit, false //	continue
+			}
+			hit = true
+			if !iter(n.items[i]) {
+				return hit, false
+			}
+		}
+		if len(n.children) > 0 {
+			if hit, ok = n.children[0].iterate(dir, start, stop, includeStart, hit, iter, ctx); !ok {
+				return hit, false
+			}
+		}
+	}
+	return hit, true
+}
+
+// Used for testing/debugging purposes.
+func (n *node) print(w io.Writer, level int) {
+	fmt.Fprintf(w, "%sNODE:%v\n", strings.Repeat("  ", level), n.items)
+	for _, c := range n.children {
+		c.print(w, level+1)
+	}
+}
+
+// BTree is an implementation of a B-Tree.
+//
+// BTree stores Item instances in an ordered structure, allowing easy insertion,
+// removal, and iteration.
+//
+// Write operations are not safe for concurrent mutation by multiple
+// goroutines, but Read operations are.
+type BTree struct {
+	degree int
+	length int
+	root   *node
+	ctx    interface{}
+	cow    *copyOnWriteContext
+}
+
+// copyOnWriteContext pointers determine node ownership... a tree with a write
+// context equivalent to a node's write context is allowed to modify that node.
+// A tree whose write context does not match a node's is not allowed to modify
+// it, and must create a new, writable copy (IE: it's a Clone).
+//
+// When doing any write operation, we maintain the invariant that the current
+// node's context is equal to the context of the tree that requested the write.
+// We do this by, before we descend into any node, creating a copy with the
+// correct context if the contexts don't match.
+//
+// Since the node we're currently visiting on any write has the requesting
+// tree's context, that node is modifiable in place.  Children of that node may
+// not share context, but before we descend into them, we'll make a mutable
+// copy.
+type copyOnWriteContext struct {
+	freelist *FreeList
+}
+
+// Clone clones the btree, lazily.  Clone should not be called concurrently,
+// but the original tree (t) and the new tree (t2) can be used concurrently
+// once the Clone call completes.
+//
+// The internal tree structure of b is marked read-only and shared between t and
+// t2.  Writes to both t and t2 use copy-on-write logic, creating new nodes
+// whenever one of b's original nodes would have been modified.  Read operations
+// should have no performance degredation.  Write operations for both t and t2
+// will initially experience minor slow-downs caused by additional allocs and
+// copies due to the aforementioned copy-on-write logic, but should converge to
+// the original performance characteristics of the original tree.
+func (t *BTree) Clone() (t2 *BTree) {
+	// Create two entirely new copy-on-write contexts.
+	// This operation effectively creates three trees:
+	//   the original, shared nodes (old b.cow)
+	//   the new b.cow nodes
+	//   the new out.cow nodes
+	cow1, cow2 := *t.cow, *t.cow
+	out := *t
+	t.cow = &cow1
+	out.cow = &cow2
+	return &out
+}
+
+// maxItems returns the max number of items to allow per node.
+func (t *BTree) maxItems() int {
+	return t.degree*2 - 1
+}
+
+// minItems returns the min number of items to allow per node (ignored for the
+// root node).
+func (t *BTree) minItems() int {
+	return t.degree - 1
+}
+
+func (c *copyOnWriteContext) newNode() (n *node) {
+	n = c.freelist.newNode()
+	n.cow = c
+	return
+}
+
+func (c *copyOnWriteContext) freeNode(n *node) {
+	if n.cow == c {
+		// clear to allow GC
+		n.items.truncate(0)
+		n.children.truncate(0)
+		n.cow = nil
+		c.freelist.freeNode(n)
+	}
+}
+
+// ReplaceOrInsert adds the given item to the tree.  If an item in the tree
+// already equals the given one, it is removed from the tree and returned.
+// Otherwise, nil is returned.
+//
+// nil cannot be added to the tree (will panic).
+func (t *BTree) ReplaceOrInsert(item Item) Item {
+	if item == nil {
+		panic("nil item being added to BTree")
+	}
+	if t.root == nil {
+		t.root = t.cow.newNode()
+		t.root.items = append(t.root.items, item)
+		t.length++
+		return nil
+	} else {
+		t.root = t.root.mutableFor(t.cow)
+		if len(t.root.items) >= t.maxItems() {
+			item2, second := t.root.split(t.maxItems() / 2)
+			oldroot := t.root
+			t.root = t.cow.newNode()
+			t.root.items = append(t.root.items, item2)
+			t.root.children = append(t.root.children, oldroot, second)
+		}
+	}
+	out := t.root.insert(item, t.maxItems(), t.ctx)
+	if out == nil {
+		t.length++
+	}
+	return out
+}
+
+// Delete removes an item equal to the passed in item from the tree, returning
+// it.  If no such item exists, returns nil.
+func (t *BTree) Delete(item Item) Item {
+	return t.deleteItem(item, removeItem, t.ctx)
+}
+
+// DeleteMin removes the smallest item in the tree and returns it.
+// If no such item exists, returns nil.
+func (t *BTree) DeleteMin() Item {
+	return t.deleteItem(nil, removeMin, t.ctx)
+}
+
+// DeleteMax removes the largest item in the tree and returns it.
+// If no such item exists, returns nil.
+func (t *BTree) DeleteMax() Item {
+	return t.deleteItem(nil, removeMax, t.ctx)
+}
+
+func (t *BTree) deleteItem(item Item, typ toRemove, ctx interface{}) Item {
+	if t.root == nil || len(t.root.items) == 0 {
+		return nil
+	}
+	t.root = t.root.mutableFor(t.cow)
+	out := t.root.remove(item, t.minItems(), typ, ctx)
+	if len(t.root.items) == 0 && len(t.root.children) > 0 {
+		oldroot := t.root
+		t.root = t.root.children[0]
+		t.cow.freeNode(oldroot)
+	}
+	if out != nil {
+		t.length--
+	}
+	return out
+}
+
+// AscendRange calls the iterator for every value in the tree within the range
+// [greaterOrEqual, lessThan), until iterator returns false.
+func (t *BTree) AscendRange(greaterOrEqual, lessThan Item, iterator ItemIterator) {
+	if t.root == nil {
+		return
+	}
+	t.root.iterate(ascend, greaterOrEqual, lessThan, true, false, iterator, t.ctx)
+}
+
+// AscendLessThan calls the iterator for every value in the tree within the range
+// [first, pivot), until iterator returns false.
+func (t *BTree) AscendLessThan(pivot Item, iterator ItemIterator) {
+	if t.root == nil {
+		return
+	}
+	t.root.iterate(ascend, nil, pivot, false, false, iterator, t.ctx)
+}
+
+// AscendGreaterOrEqual calls the iterator for every value in the tree within
+// the range [pivot, last], until iterator returns false.
+func (t *BTree) AscendGreaterOrEqual(pivot Item, iterator ItemIterator) {
+	if t.root == nil {
+		return
+	}
+	t.root.iterate(ascend, pivot, nil, true, false, iterator, t.ctx)
+}
+
+// Ascend calls the iterator for every value in the tree within the range
+// [first, last], until iterator returns false.
+func (t *BTree) Ascend(iterator ItemIterator) {
+	if t.root == nil {
+		return
+	}
+	t.root.iterate(ascend, nil, nil, false, false, iterator, t.ctx)
+}
+
+// DescendRange calls the iterator for every value in the tree within the range
+// [lessOrEqual, greaterThan), until iterator returns false.
+func (t *BTree) DescendRange(lessOrEqual, greaterThan Item, iterator ItemIterator) {
+	if t.root == nil {
+		return
+	}
+	t.root.iterate(descend, lessOrEqual, greaterThan, true, false, iterator, t.ctx)
+}
+
+// DescendLessOrEqual calls the iterator for every value in the tree within the range
+// [pivot, first], until iterator returns false.
+func (t *BTree) DescendLessOrEqual(pivot Item, iterator ItemIterator) {
+	if t.root == nil {
+		return
+	}
+	t.root.iterate(descend, pivot, nil, true, false, iterator, t.ctx)
+}
+
+// DescendGreaterThan calls the iterator for every value in the tree within
+// the range (pivot, last], until iterator returns false.
+func (t *BTree) DescendGreaterThan(pivot Item, iterator ItemIterator) {
+	if t.root == nil {
+		return
+	}
+	t.root.iterate(descend, nil, pivot, false, false, iterator, t.ctx)
+}
+
+// Descend calls the iterator for every value in the tree within the range
+// [last, first], until iterator returns false.
+func (t *BTree) Descend(iterator ItemIterator) {
+	if t.root == nil {
+		return
+	}
+	t.root.iterate(descend, nil, nil, false, false, iterator, t.ctx)
+}
+
+// Get looks for the key item in the tree, returning it.  It returns nil if
+// unable to find that item.
+func (t *BTree) Get(key Item) Item {
+	if t.root == nil {
+		return nil
+	}
+	return t.root.get(key, t.ctx)
+}
+
+// Min returns the smallest item in the tree, or nil if the tree is empty.
+func (t *BTree) Min() Item {
+	return min(t.root)
+}
+
+// Max returns the largest item in the tree, or nil if the tree is empty.
+func (t *BTree) Max() Item {
+	return max(t.root)
+}
+
+// Has returns true if the given key is in the tree.
+func (t *BTree) Has(key Item) bool {
+	return t.Get(key) != nil
+}
+
+// Len returns the number of items currently in the tree.
+func (t *BTree) Len() int {
+	return t.length
+}
+
+// Int implements the Item interface for integers.
+type Int int
+
+// Less returns true if int(a) < int(b).
+func (a Int) Less(b Item, ctx interface{}) bool {
+	return a < b.(Int)
+}
+
+type stackItem struct {
+	n *node // current node
+	i int   // index of the next child/item.
+}
+
+// Cursor represents an iterator that can traverse over all items in the tree
+// in sorted order.
+//
+// Changing data while traversing a cursor may result in unexpected items to
+// be returned. You must reposition your cursor after mutating data.
+type Cursor struct {
+	t     *BTree
+	stack []stackItem
+}
+
+// Cursor returns a new cursor used to traverse over items in the tree.
+func (t *BTree) Cursor() *Cursor {
+	return &Cursor{t: t}
+}
+
+// First moves the cursor to the first item in the tree and returns that item.
+func (c *Cursor) First() Item {
+	c.stack = c.stack[:0]
+	n := c.t.root
+	if n == nil {
+		return nil
+	}
+	c.stack = append(c.stack, stackItem{n: n})
+	for len(n.children) > 0 {
+		n = n.children[0]
+		c.stack = append(c.stack, stackItem{n: n})
+	}
+	if len(n.items) == 0 {
+		return nil
+	}
+	return n.items[0]
+}
+
+// Next moves the cursor to the next item and returns that item.
+func (c *Cursor) Next() Item {
+	if len(c.stack) == 0 {
+		return nil
+	}
+	si := len(c.stack) - 1
+	c.stack[si].i++
+	n := c.stack[si].n
+	i := c.stack[si].i
+	if i == len(n.children)+len(n.items) {
+		c.stack = c.stack[:len(c.stack)-1]
+		return c.Next()
+	}
+	if len(n.children) == 0 {
+		if i >= len(n.items) {
+			c.stack = c.stack[:len(c.stack)-1]
+			return c.Next()
+		}
+		return n.items[i]
+	} else if i%2 == 1 {
+		return n.items[i/2]
+	}
+	c.stack = append(c.stack, stackItem{n: n.children[i/2], i: -1})
+	return c.Next()
+
+}
+
+// Last moves the cursor to the last item in the tree and returns that item.
+func (c *Cursor) Last() Item {
+	c.stack = c.stack[:0]
+	n := c.t.root
+	if n == nil {
+		return nil
+	}
+	c.stack = append(c.stack, stackItem{n: n, i: len(n.children) + len(n.items) - 1})
+	for len(n.children) > 0 {
+		n = n.children[len(n.children)-1]
+		c.stack = append(c.stack, stackItem{n: n, i: len(n.children) + len(n.items) - 1})
+	}
+	if len(n.items) == 0 {
+		return nil
+	}
+	return n.items[len(n.items)-1]
+}
+
+// Prev moves the cursor to the previous item and returns that item.
+func (c *Cursor) Prev() Item {
+	if len(c.stack) == 0 {
+		return nil
+	}
+	si := len(c.stack) - 1
+	c.stack[si].i--
+	n := c.stack[si].n
+	i := c.stack[si].i
+	if i == -1 {
+		c.stack = c.stack[:len(c.stack)-1]
+		return c.Prev()
+	}
+	if len(n.children) == 0 {
+		return n.items[i]
+	} else if i%2 == 1 {
+		return n.items[i/2]
+	}
+	child := n.children[i/2]
+	c.stack = append(c.stack, stackItem{n: child,
+		i: len(child.children) + len(child.items)})
+	return c.Prev()
+}
+
+// Seek moves the cursor to provided item and returns that item.
+// If the item does not exist then the next item is returned.
+func (c *Cursor) Seek(pivot Item) Item {
+	c.stack = c.stack[:0]
+	n := c.t.root
+	for n != nil {
+		i, found := n.items.find(pivot, c.t.ctx)
+		c.stack = append(c.stack, stackItem{n: n})
+		if found {
+			if len(n.children) == 0 {
+				c.stack[len(c.stack)-1].i = i
+			} else {
+				c.stack[len(c.stack)-1].i = i*2 + 1
+			}
+			return n.items[i]
+		}
+		if len(n.children) == 0 {
+			if i == len(n.items) {
+				c.stack[len(c.stack)-1].i = i + 1
+				return c.Next()
+			}
+			c.stack[len(c.stack)-1].i = i
+			return n.items[i]
+		}
+		c.stack[len(c.stack)-1].i = i * 2
+		n = n.children[i]
+	}
+	return nil
+}

vendor/github.com/tidwall/buntdb/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Josh Baker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/tidwall/buntdb/README.md

@@ -0,0 +1,606 @@
+<p align="center">
+<img 
+    src="logo.png" 
+    width="307" height="150" border="0" alt="BuntDB">
+<br>
+<a href="https://travis-ci.org/tidwall/buntdb"><img src="https://img.shields.io/travis/tidwall/buntdb.svg?style=flat-square" alt="Build Status"></a>
+<a href="http://gocover.io/github.com/tidwall/buntdb"><img src="https://img.shields.io/badge/coverage-95%25-brightgreen.svg?style=flat-square" alt="Code Coverage"></a>
+<a href="https://goreportcard.com/report/github.com/tidwall/buntdb"><img src="https://goreportcard.com/badge/github.com/tidwall/buntdb?style=flat-square" alt="Go Report Card"></a>
+<a href="https://godoc.org/github.com/tidwall/buntdb"><img src="https://img.shields.io/badge/api-reference-blue.svg?style=flat-square" alt="GoDoc"></a>
+</p>
+
+====
+
+BuntDB is a low-level, in-memory, key/value store in pure Go. 
+It persists to disk, is ACID compliant, and uses locking for multiple
+readers and a single writer. It supports custom indexes and geospatial 
+data. It's ideal for projects that need a dependable database and favor 
+speed over data size.
+
+The desire to create BuntDB stems from the need for a new embeddable
+database for [Tile38](https://github.com/tidwall/tile38) and [SummitDB](https://github.com/tidwall/summitdb).
+
+Features
+========
+
+- In-memory database for [fast reads and writes](#performance)
+- Embeddable with a [simple API](https://godoc.org/github.com/tidwall/buntdb)
+- [Spatial indexing](#spatial-indexes) for up to 20 dimensions; Useful for Geospatial data
+- Index fields inside [JSON](#json-indexes) documents
+- [Collate i18n Indexes](#collate-i18n-indexes) using the optional [collate package](https://github.com/tidwall/collate)
+- Create [custom indexes](#custom-indexes) for any data type
+- Support for [multi value indexes](#multi-value-index); Similar to a SQL multi column index
+- [Built-in types](#built-in-types) that are easy to get up & running; String, Uint, Int, Float
+- Flexible [iteration](#iterating) of data; ascending, descending, and ranges
+- [Durable append-only file](#append-only-file) format for persistence
+- Option to evict old items with an [expiration](#data-expiration) TTL
+- Tight codebase, under 2K loc using the `cloc` command
+- ACID semantics with locking [transactions](#transactions) that support rollbacks
+
+
+Getting Started
+===============
+
+## Installing
+
+To start using BuntDB, install Go and run `go get`:
+
+```sh
+$ go get -u github.com/tidwall/buntdb
+```
+
+This will retrieve the library.
+
+
+## Opening a database
+
+The primary object in BuntDB is a `DB`. To open or create your 
+database, use the `buntdb.Open()` function:
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/tidwall/buntdb"
+)
+
+func main() {
+	// Open the data.db file. It will be created if it doesn't exist.
+	db, err := buntdb.Open("data.db")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+	
+	... 
+}
+```
+
+It's also possible to open a database that does not persist to disk by using `:memory:` as the path of the file.
+
+```go
+buntdb.Open(":memory:") // Open a file that does not persist to disk.
+```
+
+## Transactions
+All reads and writes must be performed from inside a transaction. BuntDB can have one write transaction opened at a time, but can have many concurrent read transactions. Each transaction maintains a stable view of the database. In other words, once a transaction has begun, the data for that transaction cannot be changed by other transactions.
+
+Transactions run in a function that exposes a `Tx` object, which represents the transaction state. While inside a transaction, all database operations should be performed using this object. You should never access the origin `DB` object while inside a transaction. Doing so may have side-effects, such as blocking your application.
+
+When a transaction fails, it will roll back, and revert all changes that occurred to the database during that transaction. There's a single return value that you can use to close the transaction. For read/write transactions, returning an error this way will force the transaction to roll back. When a read/write transaction succeeds all changes are persisted to disk.
+
+### Read-only Transactions
+A read-only transaction should be used when you don't need to make changes to the data. The advantage of a read-only transaction is that there can be many running concurrently.
+
+```go
+err := db.View(func(tx *buntdb.Tx) error {
+    ...
+    return nil
+})
+```
+
+### Read/write Transactions
+A read/write transaction is used when you need to make changes to your data. There can only be one read/write transaction running at a time. So make sure you close it as soon as you are done with it. 
+
+```go
+err := db.Update(func(tx *buntdb.Tx) error {
+    ...
+    return nil
+})
+```
+
+## Setting and getting key/values
+
+To set a value you must open a read/write transaction:
+
+```go
+err := db.Update(func(tx *buntdb.Tx) error {
+    _, _, err := tx.Set("mykey", "myvalue", nil)
+    return err
+})
+```
+
+
+To get the value:
+
+```go
+err := db.View(func(tx *buntdb.Tx) error {
+    val, err := tx.Get("mykey") 
+    if err != nil{
+    	return err
+    }
+    fmt.Printf("value is %s\n", val) 
+    return nil
+})
+```
+
+Getting non-existent values will case an `ErrNotFound` error.
+
+### Iterating
+All keys/value pairs are ordered in the database by the key. To iterate over the keys:
+
+```go
+err := db.View(func(tx *buntdb.Tx) error {
+err := tx.Ascend("", func(key, value string) bool{
+    	fmt.Printf("key: %s, value: %s\n", key, value)
+    })
+    return err
+})
+```
+
+There is also `AscendGreaterOrEqual`, `AscendLessThan`, `AscendRange`, `Descend`, `DescendLessOrEqual`, `DescendGreaterThan`, and `DescendRange`. Please see the [documentation](https://godoc.org/github.com/tidwall/buntdb) for more information on these functions.
+
+
+## Custom Indexes
+Initially all data is stored in a single [B-tree](https://en.wikipedia.org/wiki/B-tree) with each item having one key and one value. All of these items are ordered by the key. This is great for quickly getting a value from a key or [iterating](#iterating) over the keys. Feel free to peruse the [B-tree implementation](https://github.com/tidwall/btree).
+
+You can also create custom indexes that allow for ordering and [iterating](#iterating) over values. A custom index also uses a B-tree, but it's more flexible because it allows for custom ordering.
+
+For example, let's say you want to create an index for ordering names:
+
+```go
+db.CreateIndex("names", "*", buntdb.IndexString)
+```
+
+This will create an index named `names` which stores and sorts all values. The second parameter is a pattern that is used to filter on keys. A `*` wildcard argument means that we want to accept all keys. `IndexString` is a built-in function that performs case-insensitive ordering on the values
+
+Now you can add various names:
+
+```go
+db.Update(func(tx *buntdb.Tx) error {
+    tx.Set("user:0:name", "tom", nil)
+	tx.Set("user:1:name", "Randi", nil)
+	tx.Set("user:2:name", "jane", nil)
+	tx.Set("user:4:name", "Janet", nil)
+	tx.Set("user:5:name", "Paula", nil)
+	tx.Set("user:6:name", "peter", nil)
+	tx.Set("user:7:name", "Terri", nil)
+	return nil
+})
+```
+
+Finally you can iterate over the index:
+
+```go
+db.View(func(tx *buntdb.Tx) error {
+	tx.Ascend("names", func(key, val string) bool {
+		fmt.Printf(buf, "%s %s\n", key, val)
+		return true
+	})
+    return nil
+})
+```
+The output should be:
+```
+user:2:name jane
+user:4:name Janet
+user:5:name Paula
+user:6:name peter
+user:1:name Randi
+user:7:name Terri
+user:0:name tom
+```
+
+The pattern parameter can be used to filter on keys like this:
+
+```go
+db.CreateIndex("names", "user:*", buntdb.IndexString)
+```
+
+Now only items with keys that have the prefix `user:` will be added to the `names` index.
+
+
+### Built-in types
+Along with `IndexString`, there is also `IndexInt`, `IndexUint`, and `IndexFloat`. 
+These are built-in types for indexing. You can choose to use these or create your own.
+
+So to create an index that is numerically ordered on an age key, we could use:
+
+```go
+db.CreateIndex("ages", "user:*:age", buntdb.IndexInt)
+```
+
+And then add values:
+
+```go
+db.Update(func(tx *buntdb.Tx) error {
+    tx.Set("user:0:age", "35", nil)
+	tx.Set("user:1:age", "49", nil)
+	tx.Set("user:2:age", "13", nil)
+	tx.Set("user:4:age", "63", nil)
+	tx.Set("user:5:age", "8", nil)
+	tx.Set("user:6:age", "3", nil)
+	tx.Set("user:7:age", "16", nil)
+	return nil
+})
+```
+
+```go
+db.View(func(tx *buntdb.Tx) error {
+	tx.Ascend("ages", func(key, val string) bool {
+		fmt.Printf(buf, "%s %s\n", key, val)
+		return true
+	})
+    return nil
+})
+```
+
+The output should be:
+```
+user:6:name 3
+user:5:name 8
+user:2:name 13
+user:7:name 16
+user:0:name 35
+user:1:name 49
+user:4:name 63
+```
+
+## Spatial Indexes
+BuntDB has support for spatial indexes by storing rectangles in an [R-tree](https://en.wikipedia.org/wiki/R-tree). An R-tree is organized in a similar manner as a [B-tree](https://en.wikipedia.org/wiki/B-tree), and both are balanced trees. But, an R-tree is special because it can operate on data that is in multiple dimensions. This is super handy for Geospatial applications.
+
+To create a spatial index use the `CreateSpatialIndex` function:
+
+```go
+db.CreateSpatialIndex("fleet", "fleet:*:pos", buntdb.IndexRect)
+```
+
+Then `IndexRect` is a built-in function that converts rect strings to a format that the R-tree can use. It's easy to use this function out of the box, but you might find it better to create a custom one that renders from a different format, such as [Well-known text](https://en.wikipedia.org/wiki/Well-known_text) or [GeoJSON](http://geojson.org/).
+
+To add some lon,lat points to the `fleet` index:
+
+```go
+db.Update(func(tx *buntdb.Tx) error {
+    tx.Set("fleet:0:pos", "[-115.567 33.532]", nil)
+	tx.Set("fleet:1:pos", "[-116.671 35.735]", nil)
+	tx.Set("fleet:2:pos", "[-113.902 31.234]", nil)
+	return nil
+})
+```
+
+And then you can run the `Intersects` function on the index:
+
+```go
+db.View(func(tx *buntdb.Tx) error {
+    tx.Intersects("fleet", "[-117 30],[-112 36]", func(key, val string) bool {
+    	...
+    	return true
+    })
+    return nil
+})
+```
+
+This will get all three positions.
+
+### Spatial bracket syntax
+
+The bracket syntax `[-117 30],[-112 36]` is unique to BuntDB, and it's how the built-in rectangles are processed. But, you are not limited to this syntax. Whatever Rect function you choose to use during `CreateSpatialIndex` will be used to process the parameter, in this case it's `IndexRect`.
+
+- **2D rectangle:** `[10 15],[20 25]`  
+*Min XY: "10x15", Max XY: "20x25"*
+
+- **3D rectangle:** `[10 15 12],[20 25 18]`  
+*Min XYZ: "10x15x12", Max XYZ: "20x25x18"*
+
+- **2D point:** `[10 15]`  
+*XY: "10x15"*
+
+- **LatLon point:** `[-112.2693 33.5123]`  
+*LatLon: "33.5123 -112.2693"*
+
+- **LatLon bounding box:** `[-112.26 33.51],[-112.18 33.67]`  
+*Min LatLon: "33.51 -112.26", Max LatLon: "33.67 -112.18"*
+
+**Notice:** The longitude is the Y axis and is on the left, and latitude is the X axis and is on the right.
+
+You can also represent `Infinity` by using `-inf` and `+inf`.  
+For example, you might have the following points (`[X Y M]` where XY is a point and M is a timestamp):
+```
+[3 9 1]
+[3 8 2]
+[4 8 3]
+[4 7 4]
+[5 7 5]
+[5 6 6]
+```
+
+You can then do a search for all points with `M` between 2-4 by calling `Intersects`.
+
+```go
+tx.Intersects("points", "[-inf -inf 2],[+inf +inf 4]", func(key, val string) bool {
+    println(val)
+    return true
+})
+```
+
+Which will return:
+
+```
+[3 8 2]
+[4 8 3]
+[4 7 4]
+```
+
+## JSON Indexes
+Indexes can be created on individual fields inside JSON documents. BuntDB uses [GJSON](https://github.com/tidwall/gjson) under the hood.
+
+For example:
+
+```go
+package main
+
+import (
+	"fmt"
+
+	"github.com/tidwall/buntdb"
+)
+
+func main() {
+	db, _ := buntdb.Open(":memory:")
+	db.CreateIndex("last_name", "*", buntdb.IndexJSON("name.last"))
+	db.CreateIndex("age", "*", buntdb.IndexJSON("age"))
+	db.Update(func(tx *buntdb.Tx) error {
+		tx.Set("1", `{"name":{"first":"Tom","last":"Johnson"},"age":38}`, nil)
+		tx.Set("2", `{"name":{"first":"Janet","last":"Prichard"},"age":47}`, nil)
+		tx.Set("3", `{"name":{"first":"Carol","last":"Anderson"},"age":52}`, nil)
+		tx.Set("4", `{"name":{"first":"Alan","last":"Cooper"},"age":28}`, nil)
+		return nil
+	})
+	db.View(func(tx *buntdb.Tx) error {
+		fmt.Println("Order by last name")
+		tx.Ascend("last_name", func(key, value string) bool {
+			fmt.Printf("%s: %s\n", key, value)
+			return true
+		})
+		fmt.Println("Order by age")
+		tx.Ascend("age", func(key, value string) bool {
+			fmt.Printf("%s: %s\n", key, value)
+			return true
+		})
+		fmt.Println("Order by age range 30-50")
+		tx.AscendRange("age", `{"age":30}`, `{"age":50}`, func(key, value string) bool {
+			fmt.Printf("%s: %s\n", key, value)
+			return true
+		})
+		return nil
+	})
+}
+```
+
+Results:
+
+```
+Order by last name
+3: {"name":{"first":"Carol","last":"Anderson"},"age":52}
+4: {"name":{"first":"Alan","last":"Cooper"},"age":28}
+1: {"name":{"first":"Tom","last":"Johnson"},"age":38}
+2: {"name":{"first":"Janet","last":"Prichard"},"age":47}
+
+Order by age
+4: {"name":{"first":"Alan","last":"Cooper"},"age":28}
+1: {"name":{"first":"Tom","last":"Johnson"},"age":38}
+2: {"name":{"first":"Janet","last":"Prichard"},"age":47}
+3: {"name":{"first":"Carol","last":"Anderson"},"age":52}
+
+Order by age range 30-50
+1: {"name":{"first":"Tom","last":"Johnson"},"age":38}
+2: {"name":{"first":"Janet","last":"Prichard"},"age":47}
+```
+
+## Multi Value Index
+With BuntDB it's possible to join multiple values on a single index. 
+This is similar to a [multi column index](http://dev.mysql.com/doc/refman/5.7/en/multiple-column-indexes.html) in a traditional SQL database.
+
+In this example we are creating a multi value index on "name.last" and "age":
+
+```go
+db, _ := buntdb.Open(":memory:")
+db.CreateIndex("last_name_age", "*", buntdb.IndexJSON("name.last"), buntdb.IndexJSON("age"))
+db.Update(func(tx *buntdb.Tx) error {
+	tx.Set("1", `{"name":{"first":"Tom","last":"Johnson"},"age":38}`, nil)
+	tx.Set("2", `{"name":{"first":"Janet","last":"Prichard"},"age":47}`, nil)
+	tx.Set("3", `{"name":{"first":"Carol","last":"Anderson"},"age":52}`, nil)
+	tx.Set("4", `{"name":{"first":"Alan","last":"Cooper"},"age":28}`, nil)
+	tx.Set("5", `{"name":{"first":"Sam","last":"Anderson"},"age":51}`, nil)
+	tx.Set("6", `{"name":{"first":"Melinda","last":"Prichard"},"age":44}`, nil)
+	return nil
+})
+db.View(func(tx *buntdb.Tx) error {
+	tx.Ascend("last_name_age", func(key, value string) bool {
+		fmt.Printf("%s: %s\n", key, value)
+		return true
+	})
+	return nil
+})
+
+// Output:
+// 5: {"name":{"first":"Sam","last":"Anderson"},"age":51}
+// 3: {"name":{"first":"Carol","last":"Anderson"},"age":52}
+// 4: {"name":{"first":"Alan","last":"Cooper"},"age":28}
+// 1: {"name":{"first":"Tom","last":"Johnson"},"age":38}
+// 6: {"name":{"first":"Melinda","last":"Prichard"},"age":44}
+// 2: {"name":{"first":"Janet","last":"Prichard"},"age":47}
+```
+
+## Descending Ordered Index
+Any index can be put in descending order by wrapping it's less function with `buntdb.Desc`.
+
+```go
+db.CreateIndex("last_name_age", "*", 
+	buntdb.IndexJSON("name.last"), 
+	buntdb.Desc(buntdb.IndexJSON("age")))
+```
+
+This will create a multi value index where the last name is ascending and the age is descending.
+
+## Collate i18n Indexes
+
+Using the external [collate package](https://github.com/tidwall/collate) it's possible to create
+indexes that are sorted by the specified language. This is similar to the [SQL COLLATE keyword](https://msdn.microsoft.com/en-us/library/ms174596.aspx) found in traditional databases.
+
+To install:
+
+```
+go get -u github.com/tidwall/collate
+```
+
+For example:
+
+```go
+import "github.com/tidwall/collate"
+
+// To sort case-insensitive in French.
+db.CreateIndex("name", "*", collate.IndexString("FRENCH_CI"))
+
+// To specify that numbers should sort numerically ("2" < "12") 
+// and use a comma to represent a decimal point.
+db.CreateIndex("amount", "*", collate.IndexString("FRENCH_NUM")) 
+```
+
+There's also support for Collation on JSON indexes:
+
+```go
+db.CreateIndex("last_name", "*", collate.IndexJSON("CHINESE_CI", "name.last"))
+```
+
+Check out the [collate project](https://github.com/tidwall/collate) for more information.
+
+## Data Expiration
+Items can be automatically evicted by using the `SetOptions` object in the `Set` function to set a `TTL`.
+
+```go
+db.Update(func(tx *buntdb.Tx) error {
+    tx.Set("mykey", "myval", &buntdb.SetOptions{Expires:true, TTL:time.Second})
+	return nil
+})
+```
+
+Now `mykey` will automatically be deleted after one second. You can remove the TTL by setting the value again with the same key/value, but with the options parameter set to nil.
+
+## Append-only File
+
+BuntDB uses an AOF (append-only file) which is a log of all database changes that occur from operations like `Set()` and `Delete()`. 
+
+The format of this file looks like:
+```
+set key:1 value1
+set key:2 value2
+set key:1 value3
+del key:2
+...
+```
+
+When the database opens again, it will read back the aof file and process each command in exact order.
+This read process happens one time when the database opens.
+From there on the file is only appended.
+
+As you may guess this log file can grow large over time.
+There's a background routine that automatically shrinks the log file when it gets too large.
+There is also a `Shrink()` function which will rewrite the aof file so that it contains only the items in the database.
+The shrink operation does not lock up the database so read and write transactions can continue while shrinking is in process.
+
+### Durability and fsync
+
+By default BuntDB executes an `fsync` once every second on the [aof file](#append-only-file). Which simply means that there's a chance that up to one second of data might be lost. If you need higher durability then there's an optional database config setting `Config.SyncPolicy` which can be set to `Always`.
+
+The `Config.SyncPolicy` has the following options:
+
+- `Never` - fsync is managed by the operating system, less safe
+- `EverySecond` - fsync every second, fast and safer, this is the default
+- `Always` - fsync after every write, very durable, slower
+
+## Config 
+
+Here are some configuration options that can be use to change various behaviors of the database.
+
+- **SyncPolicy** adjusts how often the data is synced to disk. This value can be Never, EverySecond, or Always. Default is EverySecond.
+- **AutoShrinkPercentage** is used by the background process to trigger a shrink of the aof file when the size of the file is larger than the percentage of the result of the previous shrunk file. For example, if this value is 100, and the last shrink process resulted in a 100mb file, then the new aof file must be 200mb before a shrink is triggered. Default is 100.
+- **AutoShrinkMinSize** defines the minimum size of the aof file before an automatic shrink can occur. Default is 32MB.
+- **AutoShrinkDisabled** turns off automatic background shrinking. Default is false.
+
+To update the configuration you should call `ReadConfig` followed by `SetConfig`. For example:
+
+```go
+
+var config buntdb.Config
+if err := db.ReadConfig(&config); err != nil{
+    log.Fatal(err)
+}
+if err := db.WriteConfig(config); err != nil{
+    log.Fatal(err)
+}
+```
+
+## Performance
+
+How fast is BuntDB?
+
+Here are some example [benchmarks](https://github.com/tidwall/raft-buntdb#raftstore-performance-comparison) when using BuntDB in a Raft Store implementation. 
+
+You can also run the standard Go benchmark tool from the project root directory:
+
+```
+go test --bench=.
+```
+
+### BuntDB-Benchmark
+
+There's a [custom utility](https://github.com/tidwall/buntdb-benchmark) that was created specifically for benchmarking BuntDB.
+
+*These are the results from running the benchmarks on a MacBook Pro 15" 2.8 GHz Intel Core i7:*
+
+```
+$ buntdb-benchmark -q
+GET: 4609604.74 operations per second
+SET: 248500.33 operations per second
+ASCEND_100: 2268998.79 operations per second
+ASCEND_200: 1178388.14 operations per second
+ASCEND_400: 679134.20 operations per second
+ASCEND_800: 348445.55 operations per second
+DESCEND_100: 2313821.69 operations per second
+DESCEND_200: 1292738.38 operations per second
+DESCEND_400: 675258.76 operations per second
+DESCEND_800: 337481.67 operations per second
+SPATIAL_SET: 134824.60 operations per second
+SPATIAL_INTERSECTS_100: 939491.47 operations per second
+SPATIAL_INTERSECTS_200: 561590.40 operations per second
+SPATIAL_INTERSECTS_400: 306951.15 operations per second
+SPATIAL_INTERSECTS_800: 159673.91 operations per second
+```
+
+To install this utility:
+
+```
+go get github.com/tidwall/buntdb-benchmark
+```
+
+
+
+## Contact
+Josh Baker [@tidwall](http://twitter.com/tidwall)
+
+## License
+
+BuntDB source code is available under the MIT [License](/LICENSE).

vendor/github.com/tidwall/gjson/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Josh Baker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/tidwall/gjson/README.md

@@ -0,0 +1,369 @@
+<p align="center">
+<img 
+    src="logo.png" 
+    width="240" height="78" border="0" alt="GJSON">
+<br>
+<a href="https://travis-ci.org/tidwall/gjson"><img src="https://img.shields.io/travis/tidwall/gjson.svg?style=flat-square" alt="Build Status"></a><!--
+<a href="http://gocover.io/github.com/tidwall/gjson"><img src="https://img.shields.io/badge/coverage-97%25-brightgreen.svg?style=flat-square" alt="Code Coverage"></a>
+-->
+<a href="https://godoc.org/github.com/tidwall/gjson"><img src="https://img.shields.io/badge/api-reference-blue.svg?style=flat-square" alt="GoDoc"></a>
+</p>
+
+<p align="center">get a json value quickly</a></p>
+
+GJSON is a Go package that provides a [very fast](#performance) and simple way to get a value from a json document. The purpose for this library it to give efficient json indexing for the [BuntDB](https://github.com/tidwall/buntdb) project. 
+
+Getting Started
+===============
+
+## Installing
+
+To start using GJSON, install Go and run `go get`:
+
+```sh
+$ go get -u github.com/tidwall/gjson
+```
+
+This will retrieve the library.
+
+## Get a value
+Get searches json for the specified path. A path is in dot syntax, such as "name.last" or "age". This function expects that the json is well-formed and validates. Invalid json will not panic, but it may return back unexpected results. When the value is found it's returned immediately. 
+
+```go
+package main
+
+import "github.com/tidwall/gjson"
+
+const json = `{"name":{"first":"Janet","last":"Prichard"},"age":47}`
+
+func main() {
+	value := gjson.Get(json, "name.last")
+	println(value.String())
+}
+```
+
+This will print:
+
+```
+Prichard
+```
+*There's also the [GetMany](#get-multiple-values-at-once) function to get multiple values at once, and [GetBytes](#working-with-bytes) for working with JSON byte slices.*
+
+## Path Syntax
+
+A path is a series of keys separated by a dot.
+A key may contain special wildcard characters '\*' and '?'.
+To access an array value use the index as the key.
+To get the number of elements in an array or to access a child path, use the '#' character.
+The dot and wildcard characters can be escaped with '\'.
+
+```json
+{
+  "name": {"first": "Tom", "last": "Anderson"},
+  "age":37,
+  "children": ["Sara","Alex","Jack"],
+  "fav.movie": "Deer Hunter",
+  "friends": [
+    {"first": "Dale", "last": "Murphy", "age": 44},
+    {"first": "Roger", "last": "Craig", "age": 68},
+    {"first": "Jane", "last": "Murphy", "age": 47}
+  ]
+}
+```
+```
+"name.last"          >> "Anderson"
+"age"                >> 37
+"children"           >> ["Sara","Alex","Jack"]
+"children.#"         >> 3
+"children.1"         >> "Alex"
+"child*.2"           >> "Jack"
+"c?ildren.0"         >> "Sara"
+"fav\.movie"         >> "Deer Hunter"
+"friends.#.first"    >> ["Dale","Roger","Jane"]
+"friends.1.last"     >> "Craig"
+```
+
+You can also query an array for the first match by using `#[...]`, or find all matches with `#[...]#`. 
+Queries support the `==`, `!=`, `<`, `<=`, `>`, `>=` comparison operators and the simple pattern matching `%` operator.
+
+```
+friends.#[last=="Murphy"].first    >> "Dale"
+friends.#[last=="Murphy"]#.first   >> ["Dale","Jane"]
+friends.#[age>45]#.last            >> ["Craig","Murphy"]
+friends.#[first%"D*"].last         >> "Murphy"
+```
+
+## Result Type
+
+GJSON supports the json types `string`, `number`, `bool`, and `null`. 
+Arrays and Objects are returned as their raw json types. 
+
+The `Result` type holds one of these:
+
+```
+bool, for JSON booleans
+float64, for JSON numbers
+string, for JSON string literals
+nil, for JSON null
+```
+
+To directly access the value:
+
+```go
+result.Type    // can be String, Number, True, False, Null, or JSON
+result.Str     // holds the string
+result.Num     // holds the float64 number
+result.Raw     // holds the raw json
+result.Index   // index of raw value in original json, zero means index unknown
+```
+
+There are a variety of handy functions that work on a result:
+
+```go
+result.Value() interface{}
+result.Int() int64
+result.Uint() uint64
+result.Float() float64
+result.String() string
+result.Bool() bool
+result.Array() []gjson.Result
+result.Map() map[string]gjson.Result
+result.Get(path string) Result
+result.ForEach(iterator func(key, value Result) bool)
+result.Less(token Result, caseSensitive bool) bool
+```
+
+The `result.Value()` function returns an `interface{}` which requires type assertion and is one of the following Go types:
+
+
+
+The `result.Array()` function returns back an array of values.
+If the result represents a non-existent value, then an empty array will be returned.
+If the result is not a JSON array, the return value will be an array containing one result.
+
+```go
+boolean >> bool
+number  >> float64
+string  >> string
+null    >> nil
+array   >> []interface{}
+object  >> map[string]interface{}
+```
+
+## Get nested array values
+
+Suppose you want all the last names from the following json:
+
+```json
+{
+  "programmers": [
+    {
+      "firstName": "Janet", 
+      "lastName": "McLaughlin", 
+    }, {
+      "firstName": "Elliotte", 
+      "lastName": "Hunter", 
+    }, {
+      "firstName": "Jason", 
+      "lastName": "Harold", 
+    }
+  ]
+}`
+```
+
+You would use the path "programmers.#.lastName" like such:
+
+```go
+result := gjson.Get(json, "programmers.#.lastName")
+for _,name := range result.Array() {
+	println(name.String())
+}
+```
+
+You can also query an object inside an array:
+
+```go
+name := gjson.Get(json, `programmers.#[lastName="Hunter"].firstName`)
+println(name.String())  // prints "Elliotte"
+```
+
+## Iterate through an object or array
+
+The `ForEach` function allows for quickly iterating through an object or array. 
+The key and value are passed to the iterator function for objects.
+Only the value is passed for arrays.
+Returning `false` from an iterator will stop iteration.
+
+```go
+result := gjson.Get(json, "programmers")
+result.ForEach(func(key, value gjson.Result) bool{
+	println(value.String()) 
+	return true // keep iterating
+})
+```
+
+## Simple Parse and Get
+
+There's a `Parse(json)` function that will do a simple parse, and `result.Get(path)` that will search a result.
+
+For example, all of these will return the same result:
+
+```go
+gjson.Parse(json).Get("name").Get("last")
+gjson.Get(json, "name").Get("last")
+gjson.Get(json, "name.last")
+```
+
+## Check for the existence of a value
+
+Sometimes you just want to know if a value exists. 
+
+```go
+value := gjson.Get(json, "name.last")
+if !value.Exists() {
+	println("no last name")
+} else {
+	println(value.String())
+}
+
+// Or as one step
+if gjson.Get(json, "name.last").Exists(){
+	println("has a last name")
+}
+```
+
+## Unmarshal to a map
+
+To unmarshal to a `map[string]interface{}`:
+
+```go
+m, ok := gjson.Parse(json).Value().(map[string]interface{})
+if !ok{
+	// not a map
+}
+```
+
+## Working with Bytes
+
+If your JSON is contained in a `[]byte` slice, there's the [GetBytes](https://godoc.org/github.com/tidwall/gjson#GetBytes) function. This is preferred over `Get(string(data), path)`.
+
+```go
+var json []byte = ...
+result := gjson.GetBytes(json, path)
+```
+
+If you are using the `gjson.GetBytes(json, path)` function and you want to avoid converting `result.Raw` to a `[]byte`, then you can use this pattern:
+
+```go
+var json []byte = ...
+result := gjson.GetBytes(json, path)
+var raw []byte
+if result.Index > 0 {
+    raw = json[result.Index:result.Index+len(result.Raw)]
+} else {
+    raw = []byte(result.Raw)
+}
+```
+
+This is a best-effort no allocation sub slice of the original json. This method utilizes the `result.Index` field, which is the position of the raw data in the original json. It's possible that the value of `result.Index` equals zero, in which case the `result.Raw` is converted to a `[]byte`.
+
+## Get multiple values at once
+
+The `GetMany` function can be used to get multiple values at the same time, and is optimized to scan over a JSON payload once.
+
+```go
+results := gjson.GetMany(json, "name.first", "name.last", "age")
+```
+
+The return value is a `[]Result`, which will always contain exactly the same number of items as the input paths.
+
+## Performance
+
+Benchmarks of GJSON alongside [encoding/json](https://golang.org/pkg/encoding/json/), 
+[ffjson](https://github.com/pquerna/ffjson), 
+[EasyJSON](https://github.com/mailru/easyjson),
+and [jsonparser](https://github.com/buger/jsonparser)
+
+```
+BenchmarkGJSONGet-8              	15000000	       333 ns/op	       0 B/op	       0 allocs/op
+BenchmarkGJSONUnmarshalMap-8     	  900000	      4188 ns/op	    1920 B/op	      26 allocs/op
+BenchmarkJSONUnmarshalMap-8      	  600000	      8908 ns/op	    3048 B/op	      69 allocs/op
+BenchmarkJSONUnmarshalStruct-8   	  600000	      9026 ns/op	    1832 B/op	      69 allocs/op
+BenchmarkJSONDecoder-8           	  300000	     14339 ns/op	    4224 B/op	     184 allocs/op
+BenchmarkFFJSONLexer-8           	 1500000	      3156 ns/op	     896 B/op	       8 allocs/op
+BenchmarkEasyJSONLexer-8         	 3000000	       938 ns/op	     613 B/op	       6 allocs/op
+BenchmarkJSONParserGet-8         	 3000000	       442 ns/op	      21 B/op	       0 allocs/op
+```
+
+Benchmarks for the `GetMany` function:
+
+```
+BenchmarkGJSONGetMany4Paths-8     	 4000000	       319 ns/op	     112 B/op	       0 allocs/op
+BenchmarkGJSONGetMany8Paths-8     	 8000000	       218 ns/op	      56 B/op	       0 allocs/op
+BenchmarkGJSONGetMany16Paths-8    	16000000	       160 ns/op	      56 B/op	       0 allocs/op
+BenchmarkGJSONGetMany32Paths-8    	32000000	       130 ns/op	      64 B/op	       0 allocs/op
+BenchmarkGJSONGetMany64Paths-8    	64000000	       117 ns/op	      64 B/op	       0 allocs/op
+BenchmarkGJSONGetMany128Paths-8    128000000	       109 ns/op	      64 B/op	       0 allocs/op
+```
+
+JSON document used:
+
+```json
+{
+  "widget": {
+    "debug": "on",
+    "window": {
+      "title": "Sample Konfabulator Widget",
+      "name": "main_window",
+      "width": 500,
+      "height": 500
+    },
+    "image": { 
+      "src": "Images/Sun.png",
+      "hOffset": 250,
+      "vOffset": 250,
+      "alignment": "center"
+    },
+    "text": {
+      "data": "Click Here",
+      "size": 36,
+      "style": "bold",
+      "vOffset": 100,
+      "alignment": "center",
+      "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
+    }
+  }
+}    
+```
+
+Each operation was rotated though one of the following search paths:
+
+```
+widget.window.name
+widget.image.hOffset
+widget.text.onMouseUp
+```
+
+For the `GetMany` benchmarks these paths are used:
+
+```
+widget.window.name
+widget.image.hOffset
+widget.text.onMouseUp
+widget.window.title
+widget.image.alignment
+widget.text.style
+widget.window.height
+widget.image.src
+widget.text.data
+widget.text.size
+```
+
+*These benchmarks were run on a MacBook Pro 15" 2.8 GHz Intel Core i7 using Go 1.7.*
+
+## Contact
+Josh Baker [@tidwall](http://twitter.com/tidwall)
+
+## License
+
+GJSON source code is available under the MIT [License](/LICENSE).

vendor/github.com/tidwall/grect/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Josh Baker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/tidwall/grect/README.md

@@ -0,0 +1,25 @@
+GRECT
+====
+
+Quickly get the outer rectangle for GeoJSON, WKT, WKB.
+
+```go
+	r := grect.Get(`{
+      "type": "Polygon",
+      "coordinates": [
+        [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
+          [100.0, 1.0], [100.0, 0.0] ]
+        ]
+    }`)
+	fmt.Printf("%v %v\n", r.Min, r.Max)
+	// Output:
+	// [100 0] [101 1]
+```
+
+## Contact
+Josh Baker [@tidwall](http://twitter.com/tidwall)
+
+## License
+
+GRECT source code is available under the MIT [License](/LICENSE).
+

vendor/github.com/tidwall/grect/grect.go

@@ -0,0 +1,337 @@
+package grect
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/tidwall/gjson"
+)
+
+type Rect struct {
+	Min, Max []float64
+}
+
+func (r Rect) String() string {
+	diff := len(r.Min) != len(r.Max)
+	if !diff {
+		for i := 0; i < len(r.Min); i++ {
+			if r.Min[i] != r.Max[i] {
+				diff = true
+				break
+			}
+		}
+	}
+	var buf []byte
+	buf = append(buf, '[')
+	for i, v := range r.Min {
+		if i > 0 {
+			buf = append(buf, ' ')
+		}
+		buf = append(buf, strconv.FormatFloat(v, 'f', -1, 64)...)
+	}
+	if diff {
+		buf = append(buf, ']', ',', '[')
+		for i, v := range r.Max {
+			if i > 0 {
+				buf = append(buf, ' ')
+			}
+			buf = append(buf, strconv.FormatFloat(v, 'f', -1, 64)...)
+		}
+	}
+	buf = append(buf, ']')
+	return string(buf)
+}
+
+func normalize(min, max []float64) (nmin, nmax []float64) {
+	if len(max) == 0 {
+		return min, min
+	} else if len(max) != len(min) {
+		if len(max) < len(min) {
+			max = append(max, min[len(max):]...)
+		} else if len(min) < len(max) {
+			min = append(min, max[len(min):]...)
+		}
+	}
+	match := true
+	for i := 0; i < len(min); i++ {
+		if min[i] != max[i] {
+			if match {
+				match = false
+			}
+			if min[i] > max[i] {
+				min[i], max[i] = max[i], min[i]
+			}
+		}
+	}
+	if match {
+		return min, min
+	}
+	return min, max
+}
+
+func Get(s string) Rect {
+	var i int
+	var ws bool
+	var min, max []float64
+	for ; i < len(s); i++ {
+		switch s[i] {
+		default:
+			continue
+		case ' ', '\t', '\r', '\n':
+			ws = true
+			continue
+		case '[':
+			min, max, i = getRect(s, i)
+		case '{':
+			min, max, i = getGeoJSON(s, i)
+		case 0x00, 0x01:
+			if !ws {
+				//		return parseWKB(s, i)
+			}
+		case 'p', 'P', 'l', 'L', 'm', 'M', 'g', 'G':
+			min, max, i = getWKT(s, i)
+		}
+		break
+	}
+	min, max = normalize(min, max)
+	return Rect{Min: min, Max: max}
+}
+
+func getRect(s string, i int) (min, max []float64, ri int) {
+	a := s[i:]
+	parts := strings.Split(a, ",")
+	for i := 0; i < len(parts) && i < 2; i++ {
+		part := parts[i]
+		if len(part) > 0 && (part[0] <= ' ' || part[len(part)-1] <= ' ') {
+			part = strings.TrimSpace(part)
+		}
+		if len(part) >= 2 && part[0] == '[' && part[len(part)-1] == ']' {
+			pieces := strings.Split(part[1:len(part)-1], " ")
+			if i == 0 {
+				min = make([]float64, 0, len(pieces))
+			} else {
+				max = make([]float64, 0, len(pieces))
+			}
+			for j := 0; j < len(pieces); j++ {
+				piece := pieces[j]
+				if piece != "" {
+					n, _ := strconv.ParseFloat(piece, 64)
+					if i == 0 {
+						min = append(min, n)
+					} else {
+						max = append(max, n)
+					}
+				}
+			}
+		}
+	}
+
+	// normalize
+	if len(parts) == 1 {
+		max = min
+	} else {
+		min, max = normalize(min, max)
+	}
+
+	return min, max, len(s)
+}
+
+func union(min1, max1, min2, max2 []float64) (umin, umax []float64) {
+	for i := 0; i < len(min1) || i < len(min2); i++ {
+		if i >= len(min1) {
+			// just copy min2
+			umin = append(umin, min2[i])
+			umax = append(umax, max2[i])
+		} else if i >= len(min2) {
+			// just copy min1
+			umin = append(umin, min1[i])
+			umax = append(umax, max1[i])
+		} else {
+			if min1[i] < min2[i] {
+				umin = append(umin, min1[i])
+			} else {
+				umin = append(umin, min2[i])
+			}
+			if max1[i] > max2[i] {
+				umax = append(umax, max1[i])
+			} else {
+				umax = append(umax, max2[i])
+			}
+		}
+	}
+	return umin, umax
+}
+
+func getWKT(s string, i int) (min, max []float64, ri int) {
+	switch s[i] {
+	default:
+		for ; i < len(s); i++ {
+			if s[i] == ',' {
+				return nil, nil, i
+			}
+			if s[i] == '(' {
+				return getWKTAny(s, i)
+			}
+		}
+		return nil, nil, i
+	case 'g', 'G':
+		if len(s)-i < 18 {
+			return nil, nil, i
+		}
+		return getWKTGeometryCollection(s, i+18)
+	}
+}
+
+func getWKTAny(s string, i int) (min, max []float64, ri int) {
+	min, max = make([]float64, 0, 4), make([]float64, 0, 4)
+	var depth int
+	var ni int
+	var idx int
+loop:
+	for ; i < len(s); i++ {
+		switch s[i] {
+		default:
+			if ni == 0 {
+				ni = i
+			}
+		case '(':
+			depth++
+		case ')', ' ', '\t', '\r', '\n', ',':
+			if ni != 0 {
+				n, _ := strconv.ParseFloat(s[ni:i], 64)
+				if idx >= len(min) {
+					min = append(min, n)
+					max = append(max, n)
+				} else {
+					if n < min[idx] {
+						min[idx] = n
+					} else if n > max[idx] {
+						max[idx] = n
+					}
+				}
+				idx++
+				ni = 0
+			}
+			switch s[i] {
+			case ')':
+				idx = 0
+				depth--
+				if depth == 0 {
+					i++
+					break loop
+				}
+			case ',':
+				idx = 0
+			}
+		}
+	}
+	return min, max, i
+}
+
+func getWKTGeometryCollection(s string, i int) (min, max []float64, ri int) {
+	var depth int
+	for ; i < len(s); i++ {
+		if s[i] == ',' || s[i] == ')' {
+			// do not increment the index
+			return nil, nil, i
+		}
+		if s[i] == '(' {
+			depth++
+			i++
+			break
+		}
+	}
+next:
+	for ; i < len(s); i++ {
+		switch s[i] {
+		case 'p', 'P', 'l', 'L', 'm', 'M', 'g', 'G':
+			var min2, max2 []float64
+			min2, max2, i = getWKT(s, i)
+			min, max = union(min, max, min2, max2)
+			for ; i < len(s); i++ {
+				if s[i] == ',' {
+					i++
+					goto next
+				}
+				if s[i] == ')' {
+					i++
+					goto done
+				}
+			}
+		case ' ', '\t', '\r', '\n':
+			continue
+		default:
+			goto end_early
+		}
+	}
+end_early:
+	// just balance the parens
+	for ; i < len(s); i++ {
+		if s[i] == '(' {
+			depth++
+		} else if s[i] == ')' {
+			depth--
+			if depth == 0 {
+				i++
+				break
+			}
+		}
+	}
+done:
+	return min, max, i
+}
+func getGeoJSON(s string, i int) (min, max []float64, ri int) {
+	json := s[i:]
+	switch gjson.Get(json, "type").String() {
+	default:
+		min, max = getMinMaxBrackets(gjson.Get(json, "coordinates").Raw)
+	case "Feature":
+		min, max, _ = getGeoJSON(gjson.Get(json, "geometry").String(), 0)
+	case "FeatureCollection":
+		for _, json := range gjson.Get(json, "features").Array() {
+			nmin, nmax, _ := getGeoJSON(json.String(), 0)
+			min, max = union(min, max, nmin, nmax)
+		}
+	case "GeometryCollection":
+		for _, json := range gjson.Get(json, "geometries").Array() {
+			nmin, nmax, _ := getGeoJSON(json.String(), 0)
+			min, max = union(min, max, nmin, nmax)
+		}
+	}
+	return min, max, len(json)
+}
+
+func getMinMaxBrackets(s string) (min, max []float64) {
+	var ni int
+	var idx int
+	for i := 0; i < len(s); i++ {
+		switch s[i] {
+		default:
+			if ni == 0 {
+				ni = i
+			}
+		case '[', ',', ']', ' ', '\t', '\r', '\n':
+			if ni > 0 {
+				n, _ := strconv.ParseFloat(s[ni:i], 64)
+				if idx >= len(min) {
+					min = append(min, n)
+					max = append(max, n)
+				} else {
+					if n < min[idx] {
+						min[idx] = n
+					} else if n > max[idx] {
+						max[idx] = n
+					}
+				}
+				ni = 0
+				idx++
+			}
+			if s[i] == ']' {
+				idx = 0
+			}
+
+		}
+	}
+
+	return
+}

vendor/github.com/tidwall/match/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Josh Baker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/tidwall/match/README.md

@@ -0,0 +1,31 @@
+Match
+=====
+<a href="https://travis-ci.org/tidwall/match"><img src="https://img.shields.io/travis/tidwall/match.svg?style=flat-square" alt="Build Status"></a>
+<a href="https://godoc.org/github.com/tidwall/match"><img src="https://img.shields.io/badge/api-reference-blue.svg?style=flat-square" alt="GoDoc"></a>
+
+Match is a very simple pattern matcher where '*' matches on any 
+number characters and '?' matches on any one character.
+Installing
+----------
+
+```
+go get -u github.com/tidwall/match
+```
+
+Example
+-------
+
+```go
+match.Match("hello", "*llo") 
+match.Match("jello", "?ello") 
+match.Match("hello", "h*o") 
+```
+
+
+Contact
+-------
+Josh Baker [@tidwall](http://twitter.com/tidwall)
+
+License
+-------
+Redcon source code is available under the MIT [License](/LICENSE).

vendor/github.com/tidwall/match/match.go

@@ -0,0 +1,192 @@
+// Match provides a simple pattern matcher with unicode support.
+package match
+
+import "unicode/utf8"
+
+// Match returns true if str matches pattern. This is a very
+// simple wildcard match where '*' matches on any number characters
+// and '?' matches on any one character.
+
+// pattern:
+// 	{ term }
+// term:
+// 	'*'         matches any sequence of non-Separator characters
+// 	'?'         matches any single non-Separator character
+// 	c           matches character c (c != '*', '?', '\\')
+// 	'\\' c      matches character c
+//
+func Match(str, pattern string) bool {
+	if pattern == "*" {
+		return true
+	}
+	return deepMatch(str, pattern)
+}
+func deepMatch(str, pattern string) bool {
+	for len(pattern) > 0 {
+		if pattern[0] > 0x7f {
+			return deepMatchRune(str, pattern)
+		}
+		switch pattern[0] {
+		default:
+			if len(str) == 0 {
+				return false
+			}
+			if str[0] > 0x7f {
+				return deepMatchRune(str, pattern)
+			}
+			if str[0] != pattern[0] {
+				return false
+			}
+		case '?':
+			if len(str) == 0 {
+				return false
+			}
+		case '*':
+			return deepMatch(str, pattern[1:]) ||
+				(len(str) > 0 && deepMatch(str[1:], pattern))
+		}
+		str = str[1:]
+		pattern = pattern[1:]
+	}
+	return len(str) == 0 && len(pattern) == 0
+}
+
+func deepMatchRune(str, pattern string) bool {
+	var sr, pr rune
+	var srsz, prsz int
+
+	// read the first rune ahead of time
+	if len(str) > 0 {
+		if str[0] > 0x7f {
+			sr, srsz = utf8.DecodeRuneInString(str)
+		} else {
+			sr, srsz = rune(str[0]), 1
+		}
+	} else {
+		sr, srsz = utf8.RuneError, 0
+	}
+	if len(pattern) > 0 {
+		if pattern[0] > 0x7f {
+			pr, prsz = utf8.DecodeRuneInString(pattern)
+		} else {
+			pr, prsz = rune(pattern[0]), 1
+		}
+	} else {
+		pr, prsz = utf8.RuneError, 0
+	}
+	// done reading
+	for pr != utf8.RuneError {
+		switch pr {
+		default:
+			if srsz == utf8.RuneError {
+				return false
+			}
+			if sr != pr {
+				return false
+			}
+		case '?':
+			if srsz == utf8.RuneError {
+				return false
+			}
+		case '*':
+			return deepMatchRune(str, pattern[prsz:]) ||
+				(srsz > 0 && deepMatchRune(str[srsz:], pattern))
+		}
+		str = str[srsz:]
+		pattern = pattern[prsz:]
+		// read the next runes
+		if len(str) > 0 {
+			if str[0] > 0x7f {
+				sr, srsz = utf8.DecodeRuneInString(str)
+			} else {
+				sr, srsz = rune(str[0]), 1
+			}
+		} else {
+			sr, srsz = utf8.RuneError, 0
+		}
+		if len(pattern) > 0 {
+			if pattern[0] > 0x7f {
+				pr, prsz = utf8.DecodeRuneInString(pattern)
+			} else {
+				pr, prsz = rune(pattern[0]), 1
+			}
+		} else {
+			pr, prsz = utf8.RuneError, 0
+		}
+		// done reading
+	}
+
+	return srsz == 0 && prsz == 0
+}
+
+var maxRuneBytes = func() []byte {
+	b := make([]byte, 4)
+	if utf8.EncodeRune(b, '\U0010FFFF') != 4 {
+		panic("invalid rune encoding")
+	}
+	return b
+}()
+
+// Allowable parses the pattern and determines the minimum and maximum allowable
+// values that the pattern can represent.
+// When the max cannot be determined, 'true' will be returned
+// for infinite.
+func Allowable(pattern string) (min, max string) {
+	if pattern == "" || pattern[0] == '*' {
+		return "", ""
+	}
+
+	minb := make([]byte, 0, len(pattern))
+	maxb := make([]byte, 0, len(pattern))
+	var wild bool
+	for i := 0; i < len(pattern); i++ {
+		if pattern[i] == '*' {
+			wild = true
+			break
+		}
+		if pattern[i] == '?' {
+			minb = append(minb, 0)
+			maxb = append(maxb, maxRuneBytes...)
+		} else {
+			minb = append(minb, pattern[i])
+			maxb = append(maxb, pattern[i])
+		}
+	}
+	if wild {
+		r, n := utf8.DecodeLastRune(maxb)
+		if r != utf8.RuneError {
+			if r < utf8.MaxRune {
+				r++
+				if r > 0x7f {
+					b := make([]byte, 4)
+					nn := utf8.EncodeRune(b, r)
+					maxb = append(maxb[:len(maxb)-n], b[:nn]...)
+				} else {
+					maxb = append(maxb[:len(maxb)-n], byte(r))
+				}
+			}
+		}
+	}
+	return string(minb), string(maxb)
+	/*
+		return
+		if wild {
+			r, n := utf8.DecodeLastRune(maxb)
+			if r != utf8.RuneError {
+				if r < utf8.MaxRune {
+					infinite = true
+				} else {
+					r++
+					if r > 0x7f {
+						b := make([]byte, 4)
+						nn := utf8.EncodeRune(b, r)
+						maxb = append(maxb[:len(maxb)-n], b[:nn]...)
+					} else {
+						maxb = append(maxb[:len(maxb)-n], byte(r))
+					}
+				}
+			}
+		}
+		return string(minb), string(maxb), infinite
+	*/
+}

vendor/github.com/tidwall/rtree/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016 Josh Baker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/tidwall/rtree/README.md

@@ -0,0 +1,21 @@
+RTree implementation for Go
+===========================
+
+[![Build Status](https://travis-ci.org/tidwall/rtree.svg?branch=master)](https://travis-ci.org/tidwall/rtree)
+[![GoDoc](https://godoc.org/github.com/tidwall/rtree?status.svg)](https://godoc.org/github.com/tidwall/rtree)
+
+This package provides an in-memory R-Tree implementation for Go, useful as a spatial data structure.
+It has support for 1-20 dimensions, and can store and search multidimensions interchangably in the same tree.
+
+Authors
+-------
+* 1983 Original algorithm and test code by Antonin Guttman and Michael Stonebraker, UC Berkely
+* 1994 ANCI C ported from original test code by Melinda Green 
+* 1995 Sphere volume fix for degeneracy problem submitted by Paul Brook
+* 2004 Templated C++ port by Greg Douglas
+* 2016 Go port by Josh Baker
+
+License
+-------
+RTree source code is available under the MIT License.
+

vendor/golang.org/x/crypto/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 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.